Updated Changelog and Readme to include Maven Central

.classpath

@@ -6,6 +6,12 @@
 			<attribute name="gradle_used_by_scope" value="main,test"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry kind="src" output="bin/main" path="src/main/resources">
+		<attributes>
+			<attribute name="gradle_scope" value="main"/>
+			<attribute name="gradle_used_by_scope" value="main,test"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="src" output="bin/test" path="src/test/java">
 		<attributes>
 			<attribute name="gradle_scope" value="test"/>

.github/workflows/coverage.yml

@@ -8,11 +8,11 @@ jobs:
     name: Code Quality Check
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
       - name: Set up JDK 11
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v3
         with:
           distribution: 'temurin'
           java-version: 11

.gitignore

@@ -20,7 +20,15 @@ gradle-app.setting
 /bin/
 /storage/
 #Generated Code
-
+/src/main/java/speiger/src/collections/booleans/*
+/src/main/java/speiger/src/collections/bytes/*
+/src/main/java/speiger/src/collections/shorts/*
+/src/main/java/speiger/src/collections/chars/*
+/src/main/java/speiger/src/collections/ints/*
+/src/main/java/speiger/src/collections/longs/*
+/src/main/java/speiger/src/collections/floats/*
+/src/main/java/speiger/src/collections/doubles/*
+/src/main/java/speiger/src/collections/objects/*
 
 #Generated Tests
 /src/test/java/speiger/src/testers/booleans/*

Changelog.md

@@ -1,5 +1,21 @@
 # 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.

README.md

@@ -1,5 +1,6 @@
 ![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)
@@ -43,7 +44,7 @@ To ensure that problems can be dealt with even if it is breaking the current API
 
 # How to install
 Using Jitpack Gradle
-```gradle
+```groovy
 repositories {
     maven {
         url = "https://jitpack.io"
@@ -54,6 +55,13 @@ 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

@@ -0,0 +1,15 @@
+# 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,6 +1,7 @@
 plugins {
     id 'java-library'
     id "jacoco"
+//	id "com.vanniktech.maven.publish" version "0.28.0"
 }
 
 tasks.withType(JavaCompile) {
@@ -10,6 +11,7 @@ tasks.withType(JavaCompile) {
 apply plugin: 'java'
 apply plugin: 'eclipse'
 apply plugin: 'maven-publish'
+apply plugin: 'signing'
 
 repositories {
     mavenCentral()
@@ -19,12 +21,17 @@ repositories {
 }
 
 archivesBaseName = 'Primitive Collections'
-version = '0.9.0';
+version = RELEASE_VERSION;
 
 sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaVersion.current();
 
 System.out.println("Java Version: "+compileJava.sourceCompatibility)
 
+java {
+	withJavadocJar()
+    withSourcesJar()
+}
+
 javadoc {
     options.tags = [ "implSpec", "note" ] 
 }
@@ -48,7 +55,7 @@ dependencies {
 	builderImplementation 'com.google.code.gson:gson:2.10'
 	builderImplementation 'de.speiger:Simple-Code-Generator:1.3.0'
     testImplementation 'junit:junit:4.12'
-    testImplementation 'com.google.guava:guava-testlib:33.6.0-jre'
+    testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
     
 }
 
@@ -99,26 +106,12 @@ 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'
@@ -268,13 +261,10 @@ jacocoTestReport {
     }
 }
 
+
 publishing {
-	Properties props = new Properties()
-	if(file("$buildDir/credentials.properties").exists()) {
-		props.load(new FileInputStream("$buildDir/credentials.properties"))
-	}
 	publications {
-		mavenJava(MavenPublication) {
+		personal(MavenPublication) {
 			pom {
 				name = 'Primitive Collections'
 				description = 'A Primitive Collection library that reduces memory usage and improves performance'
@@ -283,8 +273,6 @@ 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'
@@ -309,11 +297,83 @@ 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 props.mavenUser
+				username auth?[0]
-				password props.mavenPassword
+				password auth?[1]
 			}
 		}
 	}
-}
+}
+
+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,4 +1,6 @@
 org.gradle.jvmargs=-Xmx3G
 
-maxMemory = 2048m
+maxMemory = 1024m
-testThreads = 4
+testThreads = 4
+
+RELEASE_VERSION = 0.9.0

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

@@ -128,7 +128,6 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		for(int i = 0,m=modules.size();i<m;i++) {
 			modules.get(i).setManager(manager);
 		}
-		manager.resolve();
 		for(int i = 0,m=modules.size();i<m;i++) {
 			biPackages.forEach(modules.get(i)::init);
 		}

src/builder/java/speiger/src/builder/SettingsManager.java

@@ -1,100 +1,54 @@
 package speiger.src.builder;
 
 import java.io.BufferedReader;
-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.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() {
+	public boolean isModuleEnabled(BaseModule base, ClassType keyType, ClassType valueType) {
-		if(!loaded) return;
+		if(!loaded) return true;
-		Set<IDependency> roots = new LinkedHashSet<>();
+		if(!isEnabled(data, base.getModuleName())) return false;
-		Set<IDependency> leafs = new LinkedHashSet<>();
+		JsonObject result = getObject(data, keyType.getClassPath(), false);
-		for(IDependency entry : allDependencies) {
+		if(!isEnabled(result, "Enabled")) return false;
-			if(entry.isRoot()) {
+		if(base.isBiModule()) {
-				roots.add(entry);
+			result = getObject(result, valueType.getClassPath(), false);
-			}
+			if(!isEnabled(result, "Enabled")) return false;
-			if(entry.isLeaf()) {
-				leafs.add(entry);
-			}
 		}
-		/**
+		result = getObject(result, base.getModuleName(), false);
-		 * This has to be 2 iteration passes.
+		return (result.size() <= 0 || isEnabled(result, "Enabled")) && base.areDependenciesLoaded();		
-		 * 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
+	
-		 */
+	public boolean isModuleEnabled(BaseModule base, ClassType keyType, ClassType valueType, String entry)
-		for(int i = 0;i<2;i++) {
+	{
-			for(ClassType keyType : ModulePackage.TYPE) {
+		if(!loaded) return true;
-				for(ClassType valueType : ModulePackage.TYPE) {
+		if(!isEnabled(data, base.getModuleName())) return false;
-					for(IDependency entry : roots) {
+		JsonObject result = getObject(data, keyType.getClassPath(), false);
-						entry.resolveRequirements(keyType, valueType);
+		if(!isEnabled(result, "Enabled")) return false;
-					}
+		if(base.isBiModule()) {
-				}
+			result = getObject(result, valueType.getClassPath(), false);
-			}
+			if(!isEnabled(result, "Enabled")) return false;
-		}
-		
-		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));
 		}
+		result = getObject(result, base.getModuleName(), false);
+		return (result.size() <= 0 || (isEnabled(result, "Enabled") && isEnabled(result, entry))) && base.areDependenciesLoaded();
 	}
 	
 	public void addModule(BaseModule module) {
-		if(loaded) {
+		if(loaded) return;
-			if(module.isBiModule()) {
-				for(ClassType keyType : ModulePackage.TYPE) {
-					for(ClassType valueType : ModulePackage.TYPE) {
-						if(!module.isModuleValid(keyType, valueType)) continue;
-						for(IDependency dependency : module.getDependencies(keyType, valueType)) {
-							dependency.set(parsedData);
-							allDependencies.add(dependency);
-						}
-					}
-				}
-				return;
-			}
-			for(ClassType keyType : ModulePackage.TYPE) {
-				if(!module.isModuleValid(keyType, keyType)) continue;
-				for(IDependency dependency : module.getDependencies(keyType, keyType)) {
-					dependency.set(parsedData);
-					allDependencies.add(dependency);
-				}
-			}
-			return;
-		}
 		String moduleName = module.getModuleName();
 		moduleNames.add(moduleName);
 		data.addProperty(moduleName, true);
@@ -103,9 +57,9 @@ public class SettingsManager
 				for(ClassType valueType : ModulePackage.TYPE) {
 					if(!module.isModuleValid(keyType, valueType)) continue;
 					JsonObject obj = new JsonObject();
-					for(IDependency dependency : module.getDependencies(keyType, valueType)) {
+					obj.addProperty("Enabled", true);
-						String key = dependency.getName();
+					for(String key : module.getModuleKeys(keyType, valueType)) {
-						if(key != null) obj.addProperty(key, true);
+						obj.addProperty(key, true);
 					}
 					addModule(keyType, valueType, true, moduleName, obj);
 				}
@@ -115,61 +69,18 @@ public class SettingsManager
 		for(ClassType keyType : ModulePackage.TYPE) {
 			if(!module.isModuleValid(keyType, keyType)) continue;
 			JsonObject obj = new JsonObject();
-			for(IDependency dependency : module.getDependencies(keyType, keyType)) {
+			obj.addProperty("Enabled", true);
-				String key = dependency.getName();
+			for(String key : module.getModuleKeys(keyType, keyType)) {
-				if(key != null) obj.addProperty(key, true);
+				obj.addProperty(key, true);
 			}
 			addModule(keyType, keyType, false, moduleName, obj);			
 		}
 	}
 	
-	public void printModuleSettings(List<BaseModule> modules) {
-		JsonObject data = new JsonObject();
-		for(BaseModule module : modules) {
-			String moduleName = module.getModuleName();
-			if(module.isBiModule()) {
-				for(ClassType keyType : ModulePackage.TYPE) {
-					for(ClassType valueType : ModulePackage.TYPE) {
-						if(!module.isModuleValid(keyType, valueType)) continue;
-						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());
-						}
-						addModule(data, keyType, valueType, true, moduleName, obj);
-					}
-				}
-				continue;
-			}
-			for(ClassType keyType : ModulePackage.TYPE) {
-				if(!module.isModuleValid(keyType, keyType)) continue;
-				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());
-				}
-				addModule(data, keyType, keyType, false, moduleName, obj);			
-			}
-		}
-		try {
-			System.out.println();
-			JsonWriter writer = new JsonWriter(new OutputStreamWriter(System.out));
-			writer.setIndent("\t");
-			Streams.write(data, writer);
-			writer.flush();
-			System.out.println();
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-	
 	public void load() {
 		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(); }
 	}
@@ -189,14 +100,6 @@ public class SettingsManager
 		catch(Exception e) { e.printStackTrace(); }
 	}
 	
-	private void addModule(JsonObject data, ClassType keyType, ClassType valueType, boolean bi, String moduleName, JsonObject obj) {
-		JsonObject result = getObject(data, keyType.getClassPath(), true);
-		if(bi) {
-			result = getObject(result, valueType.getClassPath(), true);
-		}
-		result.add(moduleName, obj);
-	}
-	
 	private void addModule(ClassType keyType, ClassType valueType, boolean bi, String moduleName, JsonObject obj) {
 		JsonObject result = getObject(data, keyType.getClassPath(), true);
 		if(bi) {
@@ -214,4 +117,9 @@ public class SettingsManager
 		}
 		return obj;
 	}
+	
+	private boolean isEnabled(JsonObject obj, String key) {
+		if(obj.has(key)) return obj.getAsJsonPrimitive(key).getAsBoolean();
+		return true;
+	}
 }

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/modules/AsyncModule.java

@@ -1,17 +1,9 @@
 package speiger.src.builder.modules;
 
-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;
-
 @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);
 	
 	@Override
 	public String getModuleName() { return "Async"; }
@@ -24,16 +16,16 @@ public class AsyncModule extends BaseModule
 	@Override
 	protected void loadFunctions() {}
 	@Override
-	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE); }
+	public boolean areDependenciesLoaded() { return isDependencyLoaded(CollectionModule.INSTANCE); }
 	@Override
 	protected void loadBlockades() {
-		if(!MODULE.isEnabled()) {
+		if(!isModuleEnabled()) {
 			addBlockedFiles("AsyncBuilder", "Task");
 		}
 	}
 	@Override
 	protected void loadFlags() {
-		if(MODULE.isEnabled()) {
+		if(isModuleEnabled()) {
 			addKeyFlag("ASYNC_MODULE");
 		}
 	}

src/builder/java/speiger/src/builder/modules/BaseModule.java

@@ -1,15 +1,13 @@
 package speiger.src.builder.modules;
 
 import java.util.Collections;
-import java.util.List;
+import java.util.Set;
-import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 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.mappers.ArgumentMapper;
 import speiger.src.builder.mappers.InjectMapper;
 import speiger.src.builder.mappers.LineMapper;
@@ -32,9 +30,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();
@@ -61,12 +56,32 @@ public abstract class BaseModule
 	
 	public abstract String getModuleName();
 	public boolean isBiModule() { return false; }
-	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) { return Collections.emptyList(); }
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) { return Collections.emptySet(); }
 	public boolean isModuleValid(ClassType keyType, ClassType valueType) { return true; }
 	
 	public ClassType keyType() { return keyType; }
 	public ClassType valueType() { return valueType; }
 	
+	protected boolean isModuleEnabled() {
+		return manager == null || manager.isModuleEnabled(this, keyType, valueType);
+	}
+	
+	protected boolean isModuleEnabled(String name) {
+		return manager == null || manager.isModuleEnabled(this, keyType, valueType, name);
+	}
+	
+	protected boolean isDependencyLoaded(BaseModule module) {
+		return isDependencyLoaded(module, true);
+	}
+	
+	protected boolean isDependencyLoaded(BaseModule module, boolean key) {
+		return manager == null || (module.isBiModule() ? manager.isModuleEnabled(module, keyType, valueType) : (key ? manager.isModuleEnabled(module, keyType, keyType) : manager.isModuleEnabled(module, valueType, valueType))); 
+	}
+	
+	public boolean areDependenciesLoaded() {
+		return true;
+	}
+	
 	protected void addFlag(String name) {
 		entry.addFlag(name);
 	}
@@ -190,9 +205,4 @@ public abstract class BaseModule
 		entry.addMapper(mapper);
 		return mapper;
 	}
-	
-	public static <T> T make(T input, Consumer<T> processor) {
-		processor.accept(input);
-		return input;
-	}
 }

src/builder/java/speiger/src/builder/modules/CollectionModule.java

@@ -1,59 +1,52 @@
 package speiger.src.builder.modules;
 
 import java.util.Arrays;
-import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
 
 import speiger.src.builder.ClassType;
-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 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"; }
 	@Override
 	protected void loadVariables() {}
 	@Override
-	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, STREAMS, SPLIT_ITERATORS, IARRAY, STRATEGY); }
+	public boolean areDependenciesLoaded(){ return isDependencyLoaded(JavaModule.INSTANCE); }
+	
+	@Override
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType)
+	{
+		return new TreeSet<>(Arrays.asList("Streams", "Splititerators", "IArray", "Strategy"));
+	}
 	
 	@Override
 	protected void loadFlags() {
-		if(MODULE.isEnabled()) addKeyFlag("COLLECTION_MODULE");
+		if(isModuleEnabled()) addKeyFlag("COLLECTION_MODULE");
-		if(STREAMS.isEnabled()) addKeyFlag("STREAM_FEATURE");
+		if(isModuleEnabled("Streams")) addKeyFlag("STREAM_FEATURE");
-		if(SPLIT_ITERATORS.isEnabled()) addKeyFlag("SPLIT_ITERATOR_FEATURE");
+		if(isModuleEnabled("Splititerators")) addKeyFlag("SPLIT_ITERATOR_FEATURE");
-		if(IARRAY.isEnabled()) addKeyFlag("IARRAY_FEATURE");
+		if(isModuleEnabled("IArray")) addKeyFlag("IARRAY_FEATURE");
 	}
 	
 	@Override
 	protected void loadBlockades() {
-		if(!MODULE.isEnabled()) {
+		if(!isModuleEnabled()) {
 			addBlockedFiles("Iterable", "Iterables", "Iterator", "Iterators", "BidirectionalIterator", "ListIterator");
-			addBlockedFiles("Arrays", "Collection", "OrderedCollection", "AbstractCollection", "Collections", "Stack");
+			addBlockedFiles("Arrays", "Collection", "AbstractCollection", "Collections", "Stack");
 		}
-		if(!SPLIT_ITERATORS.isEnabled()) addBlockedFiles("Splititerator", "Splititerators");
+		if(!isModuleEnabled("Splititerators")) addBlockedFiles("Splititerator", "Splititerators");
-		if(!IARRAY.isEnabled()) addBlockedFiles("IArray");
+		if(!isModuleEnabled("IArray")) addBlockedFiles("IArray");
-		if(!STRATEGY.isEnabled()) addBlockedFiles("Strategy");
+		if(!isModuleEnabled("Strategy")) addBlockedFiles("Strategy");
 		
-		if(keyType.isObject())
+		if(keyType.isObject()) {
-		{
 			addBlockedFiles("Stack");
 			addBlockedFiles("CollectionStreamTester");
 		}
-		if(keyType == ClassType.BOOLEAN)
+		if(keyType == ClassType.BOOLEAN) {
-		{
 			addBlockedFiles("CollectionRemoveIfTester", "CollectionStreamTester");
 			addBlockedFilter(T -> T.endsWith("Tester") && T.startsWith("Iterable"));
 		}
@@ -91,7 +84,6 @@ public class CollectionModule extends BaseModule
 	{
 		//Abstract Classes
 		addAbstractMapper("ABSTRACT_COLLECTION", "Abstract%sCollection");
-		addAbstractMapper("REVERSED_ORDERED_COLLECTION", "Reverse%sOrderedCollection");
 		
 		//Helper Classes
 		addClassMapper("ARRAYS", "Arrays");
@@ -102,7 +94,6 @@ public class CollectionModule extends BaseModule
 		
 		//Interfaces
 		addClassMapper("COLLECTION", "Collection");
-		addClassMapper("ORDERED_COLLECTION", "OrderedCollection");
 		addClassMapper("ITERABLE", "Iterable");
 		addClassMapper("SPLIT_ITERATOR", "Splititerator");
 		addClassMapper("LIST_ITERATOR", "ListIterator");

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

@@ -1,18 +1,12 @@
 package speiger.src.builder.modules;
 
-import java.util.Arrays;
-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;
 
 @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);
 	
 	@Override
 	public String getModuleName() { return "Function"; }
@@ -25,17 +19,10 @@ public class FunctionModule extends BaseModule
 	@Override
 	protected void loadTestClasses() {}
 	
-	@Override
-	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) {
-		return Arrays.asList(MODULE);
-	}
-	
 	@Override
 	protected void loadBlockades()
 	{
 		if(keyType.isObject()) addBlockedFiles("Consumer", "Comparator");
-		if(!MODULE.isEnabled()) addBlockedFiles("Consumer", "BiConsumer", "Comparator", "Supplier", "Optional", "Function", "UnaryOperator");
-		if(!keyType.needsCustomJDKType()) addBlockedFiles("Optional");
 	}
 	
 	@Override
@@ -61,7 +48,6 @@ public class FunctionModule extends BaseModule
 		}
 		else addBiRequirement("Function");
 		addRemapper("BiConsumer", "%sConsumer");
-		addRemapper("Optional", "Optional%s");
 	}
 	
 	@Override
@@ -96,8 +82,6 @@ public class FunctionModule extends BaseModule
 		
 		addFunctionMappers("PREDICATE", "%sPredicate");
 		addClassMapper("SUPPLIER", "Supplier");
-		addSimpleMapper("OPTIONAL", keyType.isObject() ? "Optional" : String.format("Optional%s", keyType.getFileType()));
-		addSimpleMapper("VALUE_OPTIONAL", valueType.isObject() ? "Optional" : String.format("Optional%s", valueType.getFileType()));
 		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
 		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");
 		if(keyType.isObject())

src/builder/java/speiger/src/builder/modules/JavaModule.java

@@ -1,17 +1,11 @@
 package speiger.src.builder.modules;
 
-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;
 
 @SuppressWarnings("javadoc")
 public class JavaModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new JavaModule();
-	public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false);
 	
 	@Override
 	public String getModuleName() { return "Base"; }
@@ -23,11 +17,6 @@ public class JavaModule extends BaseModule
 		loadBaseVariables();
 	}
 	
-	@Override
-	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) {
-		return Arrays.asList(MODULE);
-	}
-	
 	@Override
 	protected void loadFlags()
 	{
@@ -60,8 +49,6 @@ public class JavaModule extends BaseModule
 		addSimpleMapper("APPLY_KEY_VALUE", keyType.isObject() ? "apply" : "applyAs"+keyType.getNonFileType());
 		addSimpleMapper("APPLY_VALUE", valueType.isObject() ? "apply" : "applyAs"+valueType.getNonFileType());
 		addSimpleMapper("APPLY_CAST", "applyAs"+keyType.getCustomJDKType().getNonFileType());
-		addSimpleMapper("GET_OPTIONAL", keyType.isObject() ? "ofNullable" : "of");
-		addSimpleMapper("GET_OPTIONAL_VALUE", valueType.isObject() ? "ofNullable" : "of");
 		
 		//Shared by Maps and Pairs so moved to java.
 		addFunctionMappers("ENTRY_KEY", "get%sKey");
@@ -198,7 +185,6 @@ public class JavaModule extends BaseModule
 		addComment("@Type", "@param <%s> the keyType of elements maintained by this Collection");
 		addValueComment("@ValueArrayType", "@param <%s> the keyType of array that the operation should be applied");
 		addValueComment("@ValueType", "@param <%s> the keyType of elements maintained by this Collection");
-		addSimpleMapper("@Java21", getVersion() >= 21 ? "@Override" : "");
 		addAnnontion("@PrimitiveOverride", "@Override");
 		addSimpleMapper("@PrimitiveDoc", "");
 		addAnnontion("@Primitive", "@Deprecated");

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

@@ -1,57 +1,55 @@
 package speiger.src.builder.modules;
 
 import java.util.Arrays;
-import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
 
 import speiger.src.builder.ClassType;
-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 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
-	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, IMPLEMENTATION, WRAPPERS, ARRAY_LIST, LINKED_LIST, IMMUTABLE_LIST, COPY_ON_WRITE_LIST); }
-	@Override
 	protected void loadVariables() {}
 	@Override
 	protected void loadFlags() {
-		if(MODULE.isEnabled()) addKeyFlag("LIST_MODULE");
+		if(isModuleEnabled()) addKeyFlag("LIST_MODULE");
-		if(WRAPPERS.isEnabled()) addKeyFlag("LISTS_FEATURE");
+		if(isModuleEnabled("Wrappers")) addKeyFlag("LISTS_FEATURE");
-		if(ARRAY_LIST.isEnabled()) addKeyFlag("ARRAY_LIST_FEATURE");
+		boolean implementations = isModuleEnabled("Implementations");
-		if(LINKED_LIST.isEnabled()) addKeyFlag("LINKED_LIST_FEATURE");
+		if(implementations && isModuleEnabled("ArrayList")) addKeyFlag("ARRAY_LIST_FEATURE");
-		if(IMMUTABLE_LIST.isEnabled()) addKeyFlag("IMMUTABLE_LIST_FEATURE");
+		if(implementations && isModuleEnabled("LinkedList")) addKeyFlag("LINKED_LIST_FEATURE");
-		if(COPY_ON_WRITE_LIST.isEnabled()) addKeyFlag("COPY_ON_WRITE_LIST_FEATURE");
+		if(implementations && isModuleEnabled("ImmutableList")) addKeyFlag("IMMUTABLE_LIST_FEATURE");
+		if(implementations && isModuleEnabled("CopyOnWriteList")) addKeyFlag("COPY_ON_WRITE_LIST_FEATURE");
 	}
 	
 	@Override
 	protected void loadBlockades()
 	{
-		if(!WRAPPERS.isEnabled()) addBlockedFiles("Lists");
+		if(!isModuleEnabled("Wrappers")) addBlockedFiles("Lists");
-		if(!ARRAY_LIST.isEnabled()) addBlockedFiles("ArrayList");
+		boolean implementations = !isModuleEnabled("Implementations");
-		if(!LINKED_LIST.isEnabled()) addBlockedFiles("LinkedList");
+		if(implementations || !isModuleEnabled("ArrayList")) addBlockedFiles("ArrayList");
-		if(!IMMUTABLE_LIST.isEnabled()) addBlockedFiles("ImmutableList");
+		if(implementations || !isModuleEnabled("LinkedList")) addBlockedFiles("LinkedList");
-		if(!COPY_ON_WRITE_LIST.isEnabled()) addBlockedFiles("CopyOnWriteList");
+		if(implementations || !isModuleEnabled("ImmutableList")) addBlockedFiles("ImmutableList");
-		if(!MODULE.isEnabled()) addBlockedFiles("List", "AbstractList");
+		if(implementations || !isModuleEnabled("CopyOnWriteList")) addBlockedFiles("CopyOnWriteList");
-		
+		if(!isModuleEnabled()) addBlockedFiles("List", "AbstractList");
 		
 		if(keyType.isObject()) addBlockedFiles("ListFillBufferTester");
 		if(keyType == ClassType.BOOLEAN) addBlockedFiles("ListFillBufferTester", "ListReplaceAllTester");
 	}
 	
-
+	@Override
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) {
+		return new TreeSet<>(Arrays.asList("Implementations", "Wrappers", "ArrayList", "LinkedList", "ImmutableList", "CopyOnWriteList"));
+	}
+	
+	@Override
+	public boolean areDependenciesLoaded() {
+		return isDependencyLoaded(CollectionModule.INSTANCE);
+	}
 	
 	@Override
 	protected void loadRemappers()

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

@@ -1,48 +1,15 @@
 package speiger.src.builder.modules;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
 
 import speiger.src.builder.ClassType;
-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 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 REF_MAP = MODULE.createDependency("ReferenceHashMap").addEntryDependency(IMPLEMENTATION);
-	public static final FunctionDependency LINKED_REF_MAP = MODULE.createDependency("LinkedReferenceMap").addEntryDependency(REF_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"; }
@@ -53,58 +20,79 @@ 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) {
+	public boolean areDependenciesLoaded() { return isDependencyLoaded(SetModule.INSTANCE) && isDependencyLoaded(CollectionModule.INSTANCE, false); }
-		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, REF_MAP, LINKED_REF_MAP));
+	@Override
-		return dependencies;
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) {
+		Set<String> sets = new TreeSet<>();
+		sets.addAll(Arrays.asList("Wrappers", "Implementations"));
+		sets.addAll(Arrays.asList("OrderedMap", "SortedMap"));
+		sets.addAll(Arrays.asList("ArrayMap", "ConcurrentMap", "ImmutableMap"));
+		sets.addAll(Arrays.asList("HashMap", "LinkedHashMap"));
+		sets.addAll(Arrays.asList("CustomHashMap", "LinkedCustomHashMap"));
+		sets.addAll(Arrays.asList("EnumMap", "LinkedEnumMap"));
+		sets.addAll(Arrays.asList("AVLTreeMap", "RBTreeMap"));
+		return sets;
 	}
 	
 	@Override
 	protected void loadFlags()
 	{
-		if(MODULE.isEnabled()) addFlag("MAP_MODULE");
+		if(isModuleEnabled()) addFlag("MAP_MODULE");
-		if(WRAPPERS.isEnabled()) addFlag("MAPS_FEATURE");
+		if(isModuleEnabled("Wrappers")) addFlag("MAPS_FEATURE");
-		if(ORDERED_MAP.isEnabled()) addFlag("ORDERED_MAP_FEATURE");
+		boolean implementations = isModuleEnabled("Implementations");
-		if(ARRAY_MAP.isEnabled()) addFlag("ARRAY_MAP_FEATURE");
+		boolean hashMap = implementations && isModuleEnabled("HashMap");
-		if(LINKED_MAP.isEnabled()) addFlag("LINKED_MAP_FEATURE");
+		boolean customHashMap = implementations && isModuleEnabled("CustomHashMap");
-		if(LINKED_CUSTOM_MAP.isEnabled()) addFlag("LINKED_CUSTOM_MAP_FEATURE");
+		boolean enumMap = implementations && isModuleEnabled("EnumMap");
-		if(LINKED_ENUM_MAP.isEnabled()) addFlag("LINKED_ENUM_MAP_FEATURE");
 		
-		if(SORTED_MAP.isEnabled()) addFlag("SORTED_MAP_FEATURE");
+		if(isModuleEnabled("OrderedMap")) {
-		if(AVL_TREE_MAP.isEnabled()) addFlag("AVL_TREE_MAP_FEATURE");
+			addFlag("ORDERED_MAP_FEATURE");
-		if(RB_TREE_MAP.isEnabled()) addFlag("RB_TREE_MAP_FEATURE");
+			if(isModuleEnabled("ArrayMap")) addFlag("ARRAY_MAP_FEATURE");
-		
+			if(hashMap && isModuleEnabled("LinkedHashMap")) addFlag("LINKED_MAP_FEATURE");
-		if(REF_MAP.isEnabled()) addFlag("REF_MAP_FEATURE");
+			if(customHashMap && isModuleEnabled("LinkedCustomHashMap")) addFlag("LINKED_CUSTOM_MAP_FEATURE");
-		if(LINKED_REF_MAP.isEnabled()) addFlag("LINKED_REF_MAP_FEATURE");
+			if(enumMap && isModuleEnabled("LinkedEnumMap")) addFlag("LINKED_ENUM_MAP_FEATURE");
-		
+		}
-		
+		if(isModuleEnabled("SortedMap")) {
-		if(CONCURRENT_MAP.isEnabled()) addFlag("CONCURRENT_MAP_FEATURE");
+			addFlag("SORTED_MAP_FEATURE");
-		if(IMMUTABLE_MAP.isEnabled()) addFlag("IMMUTABLE_MAP_FEATURE");
+			if(implementations && isModuleEnabled("AVLTreeMap")) addFlag("AVL_TREE_MAP_FEATURE");
-		if(HASH_MAP.isEnabled()) addFlag("MAP_FEATURE");
+			if(implementations && isModuleEnabled("RBTreeMap")) addFlag("RB_TREE_MAP_FEATURE");
-		if(CUSTOM_MAP.isEnabled()) addFlag("CUSTOM_MAP_FEATURE");
+		}
-		if(ENUM_MAP.isEnabled()) addFlag("ENUM_MAP_FEATURE");
+		if(implementations && isModuleEnabled("ConcurrentMap")) addFlag("CONCURRENT_MAP_FEATURE");
+		if(implementations && isModuleEnabled("ImmutableMap")) addFlag("IMMUTABLE_MAP_FEATURE");
+		if(hashMap) addFlag("MAP_FEATURE");
+		if(customHashMap) addFlag("CUSTOM_MAP_FEATURE");
+		if(enumMap) addFlag("ENUM_MAP_FEATURE");
 	}
 	
 	@Override
 	protected void loadBlockades()
 	{
-		if(!MODULE.isEnabled()) addBlockedFiles("Map", "AbstractMap");
+		if(!isModuleEnabled()) addBlockedFiles("Map", "AbstractMap");
-		if(!WRAPPERS.isEnabled()) addBlockedFiles("Maps");
+		if(!isModuleEnabled("Wrappers")) addBlockedFiles("Maps");
-		if(!IMMUTABLE_MAP.isEnabled()) addBlockedFiles("ImmutableOpenHashMap");
+		boolean implementations = !isModuleEnabled("Implementations");
-		if(!CONCURRENT_MAP.isEnabled()) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
+		if(implementations || !isModuleEnabled("ImmutableMap")) addBlockedFiles("ImmutableOpenHashMap");
-		if(!ORDERED_MAP.isEnabled()) addBlockedFiles("OrderedMap");
+		if(implementations || !isModuleEnabled("ConcurrentMap")) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
-		if(!REF_MAP.isEnabled()) addBlockedFiles("ReferenceHashMap");
+		
-		if(!LINKED_REF_MAP.isEnabled()) addBlockedFiles("LinkedReferenceHashMap");
+		boolean ordered = !isModuleEnabled("OrderedMap");
-		if(!HASH_MAP.isEnabled()) addBlockedFiles("OpenHashMap");
+		if(ordered) addBlockedFiles("OrderedMap");
-		if(!LINKED_MAP.isEnabled()) addBlockedFiles("LinkedOpenHashMap");
+		boolean hashMap = implementations || !isModuleEnabled("HashMap");
-		if(!CUSTOM_MAP.isEnabled()) addBlockedFiles("OpenCustomHashMap");
+		if(hashMap) addBlockedFiles("OpenHashMap");
-		if(!LINKED_CUSTOM_MAP.isEnabled()) addBlockedFiles("LinkedOpenCustomHashMap");
+		if(hashMap || ordered || !isModuleEnabled("LinkedHashMap")) addBlockedFiles("LinkedOpenHashMap");
-		if(!ENUM_MAP.isEnabled()) addBlockedFiles("EnumMap");
+		
-		if(!LINKED_ENUM_MAP.isEnabled()) addBlockedFiles("LinkedEnumMap");
+		boolean customHashMap = implementations || !isModuleEnabled("CustomHashMap");
-		if(!ARRAY_MAP.isEnabled()) addBlockedFiles("ArrayMap");
+		if(customHashMap) addBlockedFiles("OpenCustomHashMap");
-		if(!SORTED_MAP.isEnabled()) addBlockedFiles("SortedMap", "NavigableMap");
+		if(customHashMap || ordered || !isModuleEnabled("LinkedCustomHashMap")) addBlockedFiles("LinkedOpenCustomHashMap");
-		if(!AVL_TREE_MAP.isEnabled()) addBlockedFiles("AVLTreeMap");
+		
-		if(!RB_TREE_MAP.isEnabled()) addBlockedFiles("RBTreeMap");
+		boolean enumMap = implementations || !isModuleEnabled("EnumMap");
+		if(enumMap) addBlockedFiles("EnumMap");
+		if(enumMap || ordered || !isModuleEnabled("LinkedEnumMap")) addBlockedFiles("LinkedEnumMap");
+		
+		if(ordered || !isModuleEnabled("ArrayMap")) addBlockedFiles("ArrayMap");
+		
+		boolean sorted = !isModuleEnabled("SortedMap");
+		if(sorted) addBlockedFiles("SortedMap", "NavigableMap");
+		if(implementations || sorted || !isModuleEnabled("AVLTreeMap")) addBlockedFiles("AVLTreeMap");
+		if(implementations || sorted || !isModuleEnabled("RBTreeMap")) addBlockedFiles("RBTreeMap");
 		
 		if(keyType == ClassType.BOOLEAN)
 		{
@@ -137,8 +125,6 @@ public class MapModule extends BaseModule
 		addBiRequirement("AbstractMap");
 		addEnumRequirement("EnumMap");
 		addEnumRequirement("LinkedEnumMap");
-		addEnumRequirement("ReferenceHashMap");
-		addEnumRequirement("LinkedReferenceHashMap");
 		addBiRequirement("ConcurrentOpenHashMap");
 		addBiRequirement("ImmutableOpenHashMap");
 		addBiRequirement("OpenHashMap");
@@ -153,8 +139,6 @@ public class MapModule extends BaseModule
 		addRemapper("AbstractMap", "Abstract%sMap");
 		addRemapper("EnumMap", "Enum2%sMap");
 		addRemapper("LinkedEnumMap", "LinkedEnum2%sMap");
-		addRemapper("ReferenceHashMap", "Reference2%sHashMap");
-		addRemapper("LinkedReferenceHashMap", "Reference2%sLinkedHashMap");
 		addRemapper("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
 		
 		//Test Classes
@@ -212,7 +196,6 @@ public class MapModule extends BaseModule
 		addBiRequirement("SortedMapNavigationTester");
 		addBiRequirement("OrderedMapNavigationTester");
 		addBiRequirement("OrderedMapMoveTester");
-		addBiRequirement("OrderedMapPutTester");
 		addBiRequirement("MapConstructorTester");
 		
 		addRemapper("TestMapGenerator", "Test%sMapGenerator");
@@ -263,14 +246,11 @@ public class MapModule extends BaseModule
 		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
 		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
 		addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
-		addFunctionValueMappers("REF_MAP", valueType.isObject() ? "Reference2ObjectHashMap" : "Reference2%sHashMap");
-		addFunctionValueMappers("LINKED_REF_MAP", valueType.isObject() ? "Reference2ObjectLinkedHashMap" : "Reference2%sLinkedHashMap");
 		addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
 		addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
 		
 		//Abstract Classes
 		addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
-		addAbstractBiMapper("REVERSED_ORDERED_MAP", "Reversed%sOrderedMap", "2");
 		
 		//Helper Classes
 		addBiClassMapper("MAPS", "Maps", "2");

src/builder/java/speiger/src/builder/modules/PairModule.java

@@ -1,26 +1,15 @@
 package speiger.src.builder.modules;
 
 import java.util.Arrays;
-import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
 
 import speiger.src.builder.ClassType;
-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 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"; }
 	@Override
@@ -32,20 +21,20 @@ public class PairModule extends BaseModule
 	@Override
 	protected void loadTestClasses() {}
 	@Override
-	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, IMMUTABLE, MUTABLE); }
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) { return new TreeSet<>(Arrays.asList("Mutable", "Immutable")); }
 	
 	@Override
 	protected void loadFlags() {
-		if(MODULE.isEnabled()) addFlag("PAIR_MODULE");
+		if(isModuleEnabled()) addFlag("PAIR_MODULE");
-		if(MUTABLE.isEnabled()) addFlag("MUTABLE_PAIR");
+		if(isModuleEnabled("Mutable")) addFlag("MUTABLE_PAIR");
-		if(IMMUTABLE.isEnabled()) addFlag("IMMUTABLE_PAIR");
+		if(isModuleEnabled("Immutable")) addFlag("IMMUTABLE_PAIR");
 	}
 	
 	@Override
 	protected void loadBlockades() {
-		if(!MODULE.isEnabled()) addBlockedFiles("Pair");
+		if(!isModuleEnabled()) addBlockedFiles("Pair");
-		if(!MUTABLE.isEnabled()) addBlockedFiles("MutablePair");
+		if(!isModuleEnabled("Mutable")) addBlockedFiles("MutablePair");
-		if(!IMMUTABLE.isEnabled()) addBlockedFiles("ImmutablePair");
+		if(!isModuleEnabled("Immutable")) addBlockedFiles("ImmutablePair");
 	}
 	
 	@Override

src/builder/java/speiger/src/builder/modules/PrioQueueModule.java

@@ -1,26 +1,15 @@
 package speiger.src.builder.modules;
 
 import java.util.Arrays;
-import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
 
 import speiger.src.builder.ClassType;
-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 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"; }
@@ -29,26 +18,36 @@ public class PrioQueueModule extends BaseModule
 	@Override
 	protected void loadFunctions() {}
 	@Override
-	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, WRAPPERS, IMPLEMENTATION, DEQUEUE, FIFO_QUEUE, HEAP_QUEUE, ARRAY_PRIO_QUEUE); }
+	public boolean areDependenciesLoaded() { return isDependencyLoaded(CollectionModule.INSTANCE); }
+	
+	@Override
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) {
+		return new TreeSet<>(Arrays.asList("Wrappers", "Implementations", "Dequeue", "FiFoQueue", "HeapQueue", "ArrayPrioQueue"));
+	}
 	
 	@Override
 	protected void loadFlags() {
-		if(MODULE.isEnabled()) addFlag("QUEUE_MODULE");
+		if(isModuleEnabled()) addFlag("QUEUE_MODULE");
-		if(WRAPPERS.isEnabled()) addKeyFlag("QUEUES_FEATURE");
+		if(isModuleEnabled("Wrappers")) addKeyFlag("QUEUES_FEATURE");
-		if(DEQUEUE.isEnabled()) addKeyFlag("DEQUEUE_FEATURE");
+		boolean implementations = isModuleEnabled("Implementations");
-		if(FIFO_QUEUE.isEnabled()) addKeyFlag("FIFO_QUEUE_FEATURE");
+		if(isModuleEnabled("Dequeue")) {
-		if(HEAP_QUEUE.isEnabled()) addKeyFlag("HEAP_QUEUE_FEATURE");
+			addKeyFlag("DEQUEUE_FEATURE");
-		if(ARRAY_PRIO_QUEUE.isEnabled()) addKeyFlag("ARRAY_QUEUE_FEATURE");
+			if(implementations && isModuleEnabled("FiFoQueue")) addKeyFlag("FIFO_QUEUE_FEATURE");
+		}
+		if(implementations && isModuleEnabled("HeapQueue")) addKeyFlag("HEAP_QUEUE_FEATURE");
+		if(implementations && isModuleEnabled("ArrayPrioQueue")) addKeyFlag("ARRAY_QUEUE_FEATURE");
 	}
 	
 	@Override
 	protected void loadBlockades() {
-		if(!MODULE.isEnabled()) addBlockedFiles("PriorityQueue", "AbstractPriorityQueue");
+		if(!isModuleEnabled()) addBlockedFiles("PriorityQueue", "AbstractPriorityQueue");
-		if(!WRAPPERS.isEnabled()) addBlockedFiles("PriorityQueues");
+		if(!isModuleEnabled("Wrappers")) addBlockedFiles("PriorityQueues");
-		if(!DEQUEUE.isEnabled()) addBlockedFiles("PriorityDequeue");
+		boolean implementations = !isModuleEnabled("Implementations");
-		if(!FIFO_QUEUE.isEnabled()) addBlockedFiles("ArrayFIFOQueue");
+		boolean dequeue = !isModuleEnabled("Dequeue");
-		if(!HEAP_QUEUE.isEnabled()) addBlockedFiles("HeapPriorityQueue");
+		if(dequeue) addBlockedFiles("PriorityDequeue"); 
-		if(!ARRAY_PRIO_QUEUE.isEnabled()) addBlockedFiles("ArrayPriorityQueue");
+		if(dequeue || implementations || !isModuleEnabled("FiFoQueue")) addBlockedFiles("ArrayFIFOQueue");
+		if(implementations || !isModuleEnabled("HeapQueue")) addBlockedFiles("HeapPriorityQueue");
+		if(implementations || !isModuleEnabled("ArrayPrioQueue")) addBlockedFiles("ArrayPriorityQueue");
 		
 		if(keyType == ClassType.BOOLEAN) {
 			addBlockedFiles("QueueTests");

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

@@ -1,30 +1,15 @@
 package speiger.src.builder.modules;
 
 import java.util.Arrays;
-import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
 
 import speiger.src.builder.ClassType;
-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 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"; }
@@ -34,40 +19,68 @@ public class SetModule 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, WRAPPERS, ORDERED_SET, SORTED_SET, IMPLEMENTATION, ARRAY_SET, IMMUTABLE_SET, HASH_SET, LINKED_SET, CUSTOM_SET, LINKED_CUSTOM_SET, AVL_TREE_SET, RB_TREE_SET); }
+	public boolean areDependenciesLoaded() { return isDependencyLoaded(CollectionModule.INSTANCE); }
+	@Override
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) {
+		Set<String> sets = new TreeSet<>();
+		sets.addAll(Arrays.asList("Wrappers", "Implementations"));
+		sets.addAll(Arrays.asList("OrderedSet", "SortedSet"));
+		sets.addAll(Arrays.asList("ArraySet", "ImmutableSet"));
+		sets.addAll(Arrays.asList("HashSet", "LinkedHashSet"));
+		sets.addAll(Arrays.asList("CustomHashSet", "LinkedCustomHashSet"));
+		sets.addAll(Arrays.asList("AVLTreeSet", "RBTreeSet"));
+		return sets;
+	}
 	
 	@Override
 	protected void loadFlags()
 	{
-		if(MODULE.isEnabled()) addFlag("SET_MODULE");
+		if(isModuleEnabled()) addFlag("SET_MODULE");
-		if(WRAPPERS.isEnabled()) addFlag("SETS_FEATURE");
+		if(isModuleEnabled("Wrappers")) addFlag("SETS_FEATURE");
-		if(ORDERED_SET.isEnabled()) addFlag("ORDERED_SET_FEATURE");
+		boolean implementations = isModuleEnabled("Implementations");
-		if(SORTED_SET.isEnabled()) addFlag("SORTED_SET_FEATURE");
+		boolean hashSet = implementations && isModuleEnabled("HashSet");
-		if(IMMUTABLE_SET.isEnabled()) addFlag("IMMUTABLE_SET_FEATURE");
+		boolean customHashSet = implementations && isModuleEnabled("CustomHashSet");
-		if(ARRAY_SET.isEnabled()) addFlag("ARRAY_SET_FEATURE");
+		
-		if(HASH_SET.isEnabled()) addFlag("HASH_SET_FEATURE");
+		if(isModuleEnabled("OrderedSet")) {
-		if(LINKED_SET.isEnabled()) addFlag("LINKED_SET_FEATURE");
+			addFlag("ORDERED_SET_FEATURE");
-		if(CUSTOM_SET.isEnabled()) addFlag("CUSTOM_HASH_SET_FEATURE");
+			if(implementations && isModuleEnabled("ArraySet")) addFlag("ARRAY_SET_FEATURE");
-		if(LINKED_CUSTOM_SET.isEnabled()) addFlag("LINKED_CUSTOM_SET_FEATURE");
+			if(hashSet && isModuleEnabled("LinkedHashSet")) addFlag("LINKED_SET_FEATURE");
-		if(AVL_TREE_SET.isEnabled()) addFlag("AVL_TREE_SET_FEATURE");
+			if(customHashSet && isModuleEnabled("LinkedCustomHashSet")) addFlag("LINKED_CUSTOM_SET_FEATURE");
-		if(RB_TREE_SET.isEnabled()) addFlag("RB_TREE_SET_FEATURE");
+		}
+		if(isModuleEnabled("SortedSet")) {
+			addFlag("SORTED_SET_FEATURE");
+			if(implementations && isModuleEnabled("AVLTreeSet")) addFlag("AVL_TREE_SET_FEATURE");
+			if(implementations && isModuleEnabled("RBTreeSet")) addFlag("RB_TREE_SET_FEATURE");
+		}
+		if(implementations && isModuleEnabled("ImmutableSet")) addFlag("IMMUTABLE_SET_FEATURE");
+		if(hashSet) addFlag("HASH_SET_FEATURE");
+		if(customHashSet) addFlag("CUSTOM_HASH_SET_FEATURE");
 	}
 	
 	@Override
 	protected void loadBlockades()
 	{
-		if(!MODULE.isEnabled()) addBlockedFiles("Set", "AbstractSet");
+		if(!isModuleEnabled()) addBlockedFiles("Set", "AbstractSet");
-		if(!WRAPPERS.isEnabled()) addBlockedFiles("Sets");
+		if(!isModuleEnabled("Wrappers")) addBlockedFiles("Sets");
-		if(!IMMUTABLE_SET.isEnabled()) addBlockedFiles("ImmutableOpenHashSet");
+		boolean implementations = !isModuleEnabled("Implementations");
-		if(!ORDERED_SET.isEnabled()) addBlockedFiles("OrderedSet");
+		if(implementations || !isModuleEnabled("ImmutableSet")) addBlockedFiles("ImmutableOpenHashSet");
-		if(!HASH_SET.isEnabled()) addBlockedFiles("OpenHashSet");
+		
-		if(!LINKED_SET.isEnabled()) addBlockedFiles("LinkedOpenHashSet");
+		boolean ordered = !isModuleEnabled("OrderedSet");
-		if(!CUSTOM_SET.isEnabled()) addBlockedFiles("OpenCustomHashSet");
+		if(ordered) addBlockedFiles("OrderedSet");
-		if(!LINKED_CUSTOM_SET.isEnabled()) addBlockedFiles("LinkedOpenCustomHashSet");
+		boolean hashSet = implementations || !isModuleEnabled("HashSet");
-		if(!ARRAY_SET.isEnabled()) addBlockedFiles("ArraySet");
+		if(hashSet) addBlockedFiles("OpenHashSet");
-		if(!SORTED_SET.isEnabled()) addBlockedFiles("SortedSet", "NavigableSet");
+		if(hashSet || ordered || !isModuleEnabled("LinkedHashSet")) addBlockedFiles("LinkedOpenHashSet");
-		if(!AVL_TREE_SET.isEnabled()) addBlockedFiles("AVLTreeSet");
+		
-		if(!RB_TREE_SET.isEnabled()) addBlockedFiles("RBTreeSet");
+		boolean customHashSet = implementations || !isModuleEnabled("CustomHashSet");
+		if(customHashSet) addBlockedFiles("OpenCustomHashSet");
+		if(customHashSet || ordered || !isModuleEnabled("LinkedCustomHashSet")) addBlockedFiles("LinkedOpenCustomHashSet");
+		
+		if(implementations || ordered || !isModuleEnabled("ArraySet")) addBlockedFiles("ArraySet");
+		
+		boolean sorted = !isModuleEnabled("SortedSet");
+		if(sorted) addBlockedFiles("SortedSet", "NavigableSet");
+		if(implementations || sorted || !isModuleEnabled("AVLTreeSet")) addBlockedFiles("AVLTreeSet");
+		if(implementations || sorted || !isModuleEnabled("RBTreeSet")) addBlockedFiles("RBTreeSet");
 		
 		if(keyType == ClassType.BOOLEAN)
 		{
@@ -148,7 +161,6 @@ public class SetModule extends BaseModule
 		
 		//Abstract Classes
 		addAbstractMapper("ABSTRACT_SET", "Abstract%sSet");
-		addAbstractMapper("REVERSED_ORDERED_SET", "Reversed%sOrderedSet");
 		
 		//Helper Classes
 		addClassMapper("SETS", "Sets");

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

@@ -1,18 +1,12 @@
 package speiger.src.collections.PACKAGE.collections;
 
 import java.util.Collection;
-#if ORDERED_MAP_FEATURE
-import java.util.function.Supplier;
-#endif
 import java.util.Objects;
 import java.util.AbstractCollection;
 #if TYPE_OBJECT
 import java.util.function.Consumer;
 #endif
 
-#if ORDERED_MAP_FEATURE
-import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
-#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -268,79 +262,5 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 		if (a.length > size()) a[size()] = EMPTY_KEY_VALUE;
 		return a;
 	}
-
-#endif
-#if ORDERED_MAP_FEATURE
-	public static class REVERSED_ORDERED_COLLECTION KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements ORDERED_COLLECTION KEY_GENERIC_TYPE {
-		ORDERED_COLLECTION KEY_GENERIC_TYPE collection;
-		Supplier<ITERATOR KEY_GENERIC_TYPE> reverseIterator;
-		
-		public REVERSED_ORDERED_COLLECTION(ORDERED_COLLECTION KEY_GENERIC_TYPE collection, Supplier<ITERATOR KEY_GENERIC_TYPE> reverseIterator) {
-			this.collection = collection;
-			this.reverseIterator = reverseIterator;
-		}
-		
-		@Override
-		public boolean add(KEY_TYPE o) { return collection.add(o); }
-		@Override
-		public ORDERED_COLLECTION KEY_GENERIC_TYPE reversed() { return collection; }
-		@Override
-		public void addFirst(KEY_TYPE e) { collection.addLast(e); }
-		@Override
-		public void addLast(KEY_TYPE e) { collection.addFirst(e); }
-		@Override
-#if !TYPE_OBJECT
-		public boolean contains(KEY_TYPE e) { return collection.contains(e); }
-#else
-		public boolean contains(Object e) { return collection.contains(e); }
-#endif
-		@Override
-#if !TYPE_OBJECT
-		public boolean REMOVE_KEY(KEY_TYPE e) { return collection.REMOVE_KEY(e); }
-#else
-		public boolean remove(Object e) { return collection.remove(e); }
-#endif
-		@Override
-		public void clear() { collection.clear(); }
-		@Override
-		public KEY_TYPE GET_FIRST_KEY() { return collection.GET_LAST_KEY(); }
-		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() { return collection.REMOVE_LAST_KEY(); }
-		@Override
-		public KEY_TYPE GET_LAST_KEY() { return collection.GET_FIRST_KEY(); }
-		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() { return collection.REMOVE_FIRST_KEY(); }
-		@Override
-		public ITERATOR KEY_GENERIC_TYPE iterator() { return reverseIterator.get(); }
-		@Override
-		public int size() { return collection.size(); }
-	}
-	
-	public static class ReverseBiIterator KEY_GENERIC_TYPE implements LIST_ITERATOR KEY_GENERIC_TYPE {
-		LIST_ITERATOR KEY_GENERIC_TYPE it;
-		
-		public ReverseBiIterator(LIST_ITERATOR KEY_GENERIC_TYPE it) {
-			this.it = it;
-		}
-		
-		@Override
-		public KEY_TYPE NEXT() { return it.PREVIOUS(); }
-		@Override
-		public boolean hasNext() { return it.hasPrevious(); }
-		@Override
-		public boolean hasPrevious() { return it.hasNext(); }
-		@Override
-		public KEY_TYPE PREVIOUS() { return it.NEXT(); }
-		@Override
-		public void remove() { it.remove(); }
-		@Override
-		public int nextIndex() { return it.previousIndex(); }
-		@Override
-		public int previousIndex() { return it.nextIndex(); }
-		@Override
-		public void set(KEY_TYPE e) { it.set(e); }
-		@Override
-		public void add(KEY_TYPE e) { it.add(e); }
-	}
 #endif
 }

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/collections/Iterable.template

@@ -5,9 +5,6 @@ import java.util.function.Consumer;
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
-#if JDK_TYPE 
-import java.util.OPTIONAL;
-#endif
 
 #if !TYPE_OBJECT
 
@@ -33,9 +30,6 @@ import speiger.src.collections.PACKAGE.collections.OUTPUT_ITERABLE;
 #endif
 #enditerate
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
@@ -414,13 +408,13 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	 * @param filter that should be applied
 	 * @return the found value or the null equivalent variant.
 	 */
-	default OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	default KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
 			KEY_TYPE entry = iter.NEXT();
-			if(filter.test(entry)) return OPTIONAL.GET_OPTIONAL(entry);
+			if(filter.test(entry)) return entry;
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 #if !TYPE_OBJECT
@@ -465,7 +459,7 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	 * @param operator the operation that should be applied
 	 * @return the reduction result, returns null value if nothing was found
 	 */
-	default OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	default KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -477,7 +471,7 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 			}
 			state = operator.APPLY_VALUE(state, iter.NEXT());
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}	
 	
 	/**

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

@@ -1,83 +0,0 @@
-package speiger.src.collections.PACKAGE.collections;
-
-#if JAVA_VERSION>=21
-import java.util.SequencedCollection;
-
-public interface ORDERED_COLLECTION KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, SequencedCollection<CLASS_TYPE> {
-#else
-public interface ORDERED_COLLECTION KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE {
-#endif
-	@Java21
-	ORDERED_COLLECTION KEY_GENERIC_TYPE reversed();
-	
-	/**
-	 * A method to add an element to the start of a collection
-	 * @param e that should be added at the start.
-	 */
-	public void addFirst(KEY_TYPE e);
-	
-	/**
-	 * A method to add an element to the end of a collection
-	 * @param e that should be added at the end.
-	 */
-	public void addLast(KEY_TYPE e);
-	
-	/**
-	 * A method to get the first element in the collection
-	 * @return first element in the collection
-	 */
-	public KEY_TYPE GET_FIRST_KEY();
-	/**
-	 * A method to get and remove the first element in the collection
-	 * @return first element in the collection
-	 */
-	public KEY_TYPE REMOVE_FIRST_KEY();
-	/**
-	 * A method to get the last element in the collection
-	 * @return last element in the collection
-	 */
-	public KEY_TYPE GET_LAST_KEY();
-	/**
-	 * A method to get and remove the last element in the collection
-	 * @return last element in the collection
-	 */
-	public KEY_TYPE REMOVE_LAST_KEY();
-	
-#if JAVA_VERSION>=21 && !TYPE_OBJECT
-	@Override
-	@Deprecated
-	default void addFirst(CLASS_TYPE e) {
-		addFirst(OBJ_TO_KEY(e));
-	}
-	
-	@Override
-	@Deprecated
-	default void addLast(CLASS_TYPE e) {
-		addLast(OBJ_TO_KEY(e));
-	}
-	
-	@Override
-	@Deprecated
-	default CLASS_TYPE getFirst() {
-		return KEY_TO_OBJ(GET_FIRST_KEY());
-	}
-	
-	@Override
-	@Deprecated
-	default CLASS_TYPE getLast() {
-		return KEY_TO_OBJ(GET_LAST_KEY());
-	}
-	
-	@Override
-	@Deprecated
-	default CLASS_TYPE removeFirst() {
-		return KEY_TO_OBJ(REMOVE_FIRST_KEY());
-	}
-
-	@Override
-	@Deprecated
-	default CLASS_TYPE removeLast() {
-		return KEY_TO_OBJ(REMOVE_LAST_KEY());
-	}
-#endif
-}

src/builder/resources/speiger/assets/collections/templates/functions/Optional.template

@@ -1,89 +0,0 @@
-package speiger.src.collections.PACKAGE.functions;
-
-import java.util.NoSuchElementException;
-import java.util.function.Supplier;
-
-public final class OPTIONAL KEY_GENERIC_TYPE {
-	private static final OPTIONAL NO_GENERIC_TYPE EMPTY = new OPTIONALBRACES();
-	
-	private final boolean isPresent;
-	private final KEY_TYPE value;
-	
-	private OPTIONAL() {
-		this.isPresent = false;
-		this.value = EMPTY_VALUE;
-	}
-	
-	private OPTIONAL(KEY_TYPE value) {
-		this.isPresent = true;
-		this.value = value;
-	}
-	
-	public static OPTIONAL KEY_GENERIC_TYPE empty() {
-		return EMPTY;
-	}
-	
-	public static OPTIONAL KEY_GENERIC_TYPE of(KEY_TYPE value) {
-		return new OPTIONALBRACES(value);
-	}
-	
-	public KEY_TYPE SUPPLY_GET() {
-		if(!isPresent) throw new NoSuchElementException("No value present");
-		return value;
-	}
-	
-	public boolean isPresent() {
-		return isPresent;
-	}
-	
-	public boolean isEmpty() {
-		return !isPresent;
-	}
-	
-	public void ifPresent(CONSUMER KEY_GENERIC_TYPE consumer) {
-		if(isPresent) consumer.accept(value);
-	}
-	
-    public void ifPresentOrElse(CONSUMER KEY_GENERIC_TYPE action, Runnable emptyAction) {
-        if (isPresent) action.accept(value);
-        else emptyAction.run();
-    }
-	
-	public KEY_TYPE orElse(KEY_TYPE other) {
-		return isPresent ? value : other;
-	}
-	
-	public KEY_TYPE orElseGet(SUPPLIER KEY_GENERIC_TYPE other) {
-		return isPresent ? value : other.SUPPLY_GET();
-	}
-	
-	public KEY_TYPE orElseThrow() {
-        if (!isPresent) throw new NoSuchElementException("No value present");
-		return value;
-	}
-	
-    public <X extends Throwable> KEY_TYPE orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
-    	if(isPresent) return value;
-    	else throw exceptionSupplier.get();
-    }
-    
-    @Override
-    public boolean equals(Object obj) {
-    	if(obj == this) return true;
-    	if(obj instanceof OPTIONAL) {
-    		OPTIONAL KEY_GENERIC_TYPE other = (OPTIONAL KEY_GENERIC_TYPE)obj;
-    		return (isPresent && other.isPresent ? KEY_EQUALS(value, other.value) : isPresent == other.isPresent);
-    	}
-    	return false;
-    }
-    
-    @Override
-    public int hashCode() {
-    	return isPresent ? KEY_TO_HASH(value) : 0;
-    }
-    
-    @Override
-    public String toString() {
-    	return isPresent ? "OPTIONAL["+value+"]" : "OPTIONAL.empty";
-    }
-}

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/ArrayList.template

@@ -7,16 +7,6 @@ import java.util.Comparator;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
-
-#endif
 #if TYPE_OBJECT
 #if IARRAY_FEATURE || TYPE_OBJECT
 import java.util.function.Consumer;
@@ -43,9 +33,6 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.STACK;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -232,42 +219,6 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return list;
 	}
 	
-#endif
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a ArrayList
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, ObjectArrayList<T>, ObjectArrayList<T>> toList() {
-		return Collector.of(ObjectArrayList::new, ObjectArrayList::add, ObjectArrayList::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a ArrayList
-	 * @Type(T)
-	 * @return a list with the contents of the Stream
-	 */
-	public static <T> ARRAY_LIST KEY_GENERIC_TYPE toList(Stream<T> stream) {
-		return stream.collect(ObjectArrayList::new, ObjectArrayList::add, ObjectArrayList::merge);
-	}
-	
-	private ObjectArrayList<T> merge(ObjectArrayList<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a ArrayList
-	 * @return a list with the contents of the Stream
-	 */
-	public static ARRAY_LIST toList(JAVA_STREAM stream) {
-		return stream.collect(ARRAY_LIST::new, ARRAY_LIST::add, ARRAY_LIST::addAll);
-	}
-	
-#endif
 #endif
 	/**
 	 * Appends the specified element to the end of this list.
@@ -731,12 +682,12 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0;i<size;i++) {
-			if(filter.test(data[i])) return OPTIONAL.GET_OPTIONAL(data[i]);
+			if(filter.test(data[i])) return data[i];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 #if !TYPE_OBJECT
@@ -763,7 +714,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -775,7 +726,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			}
 			state = operator.APPLY_VALUE(state, data[i]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override

src/builder/resources/speiger/assets/collections/templates/lists/CopyOnWriteList.template

@@ -8,15 +8,6 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
-#endif
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -42,9 +33,6 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.STACK;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -178,42 +166,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	}
 	
 #endif
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a CopyOnWriteArrayList
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, CopyOnWriteObjectArrayList<T>, CopyOnWriteObjectArrayList<T>> toList() {
-		return Collector.of(CopyOnWriteObjectArrayList::new, CopyOnWriteObjectArrayList::add, CopyOnWriteObjectArrayList::merge);
-	}
 	
-	/**
-	 * Collects a Stream to a CopyOnWriteArrayList
-	 * @Type(T)
-	 * @return a list with the contents of the Stream
-	 */
-	public static <T> CopyOnWriteObjectArrayList KEY_GENERIC_TYPE toList(Stream<T> stream) {
-		return stream.collect(CopyOnWriteObjectArrayList::new, CopyOnWriteObjectArrayList::add, CopyOnWriteObjectArrayList::merge);
-	}
-	
-	private CopyOnWriteObjectArrayList<T> merge(CopyOnWriteObjectArrayList<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a CopyOnWriteArrayList
-	 * @return a list with the contents of the Stream
-	 */
-	public static COPY_ON_WRITE_LIST toList(JAVA_STREAM stream) {
-		return stream.collect(COPY_ON_WRITE_LIST::new, COPY_ON_WRITE_LIST::add, COPY_ON_WRITE_LIST::addAll);
-	}
-	
-#endif
-#endif
 	private void setArray(KEY_TYPE[] data) {
 		this.data = data;
 	}
@@ -582,7 +535,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	 * @return if the element was found.
 	 */
 	@Override
-	@Primitive
+	@Deprecated
 	public boolean contains(Object o) {
 		return indexOf(o) != -1;
 	}
@@ -593,7 +546,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	 * @return the index of the element if found. (if not found then -1)
 	 */
 	@Override
-	@Primitive
+	@Deprecated
 	public int indexOf(Object o) {
 		KEY_TYPE[] data = this.data;
 #if TYPE_OBJECT
@@ -617,7 +570,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	 * @return the last index of the element if found. (if not found then -1)
 	 */
 	@Override
-	@Primitive
+	@Deprecated
 	public int lastIndexOf(Object o) {
 		KEY_TYPE[] data = this.data;
 #if TYPE_OBJECT
@@ -857,13 +810,13 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		KEY_TYPE[] data = this.data;
 		for(int i = 0,m=data.length;i<m;i++) {
-			if(filter.test(data[i])) return OPTIONAL.GET_OPTIONAL(data[i]);
+			if(filter.test(data[i])) return data[i];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 #if !TYPE_OBJECT
@@ -892,7 +845,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE[] data = this.data;
 		KEY_TYPE state = EMPTY_VALUE;
@@ -905,7 +858,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 			}
 			state = operator.APPLY_VALUE(state, data[i]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override

src/builder/resources/speiger/assets/collections/templates/lists/ImmutableList.template

@@ -3,26 +3,10 @@ package speiger.src.collections.PACKAGE.lists;
 import java.util.Arrays;
 #if TYPE_OBJECT
 import java.util.Comparator;
-#else if !TYPE_BOOLEAN
-import java.util.stream.JAVA_STREAM;
-import java.util.stream.StreamSupport;
 #endif
 import java.util.Collection;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if PRIMITIVES
-import java.util.function.Supplier;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-
-import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
-#endif
-#endif
 #if TYPE_OBJECT
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -36,7 +20,6 @@ import java.util.function.PREDICATE;
 #if !JDK_FUNCTION
 import java.util.function.JAVA_PREDICATE;
 #endif
-
 import java.util.function.JAVA_UNARY_OPERATOR;
 #endif
 
@@ -44,9 +27,6 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
@@ -56,6 +36,10 @@ import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.objects.utils.ObjectArrays;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
+#if PRIMITIVES && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+import java.util.stream.JAVA_STREAM;
+import java.util.stream.StreamSupport;
+#endif
 #if SPLIT_ITERATOR_FEATURE
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
@@ -136,42 +120,6 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 		data = Arrays.copyOfRange(a, offset, offset+length);
 	}
 	
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a ImmutableList
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, COLLECTION<T>, ImmutableObjectList<T>> toList() {
-		return Collector.of(COLLECTIONS::wrapper, COLLECTION::add, ImmutableObjectList::merge, E -> new IMMUTABLE_LIST<>(E.toArray((T[])new Object[E.size()])));
-	}
-
-	/**
-	 * Collects a Stream to a ImmutableList
-	 * @Type(T)
-	 * @return a list with the contents of the Stream
-	 */
-	public static <T> ImmutableObjectList KEY_GENERIC_TYPE toList(Stream<T> stream) {
-		return stream.collect(toList());
-	}
-	
-	private static <T> COLLECTION<T> merge(COLLECTION<T> a, COLLECTION<T> b) {
-		a.addAll(b);
-		return a;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a ImmutableList
-	 * @return a list with the contents of the Stream
-	 */
-	public static IMMUTABLE_LIST toList(JAVA_STREAM stream) {
-		return new IMMUTABLE_LIST(stream.collect((Supplier<COLLECTION>)COLLECTIONS::wrapper, COLLECTION::add, COLLECTION::addAll).TO_ARRAY());
-	}
-	
-#endif
-#endif
 	@Override
 	public boolean add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
 	@Override
@@ -387,12 +335,12 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0,m=data.length;i<m;i++) {
-			if(filter.test(data[i])) return OPTIONAL.GET_OPTIONAL(data[i]);
+			if(filter.test(data[i])) return data[i];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 #if !TYPE_OBJECT
@@ -419,7 +367,7 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -431,7 +379,7 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 			}
 			state = operator.APPLY_VALUE(state, data[i]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override

src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template

@@ -4,6 +4,7 @@ package speiger.src.collections.PACKAGE.lists;
 #if DEQUEUE_FEATURE
 import java.util.Comparator;
 #endif
+
 import java.util.function.BiFunction;
 #else if PRIMITIVES
 import java.nio.JAVA_BUFFER;
@@ -11,23 +12,12 @@ import java.nio.JAVA_BUFFER;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
-#endif
 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;
@@ -42,9 +32,6 @@ import java.util.function.JAVA_PREDICATE;
 #endif
 import java.util.function.JAVA_UNARY_OPERATOR;
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #if !JDK_FUNCTION
@@ -73,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;
 
 /**
@@ -166,42 +151,6 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		for(int i = offset,m=offset+length;i<m;add(a[i++]));
 	}
 	
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a LinkedList
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, ObjectLinkedList<T>, ObjectLinkedList<T>> toList() {
-		return Collector.of(ObjectLinkedList::new, ObjectLinkedList::add, ObjectLinkedList::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a LinkedList
-	 * @Type(T)
-	 * @return a list with the contents of the Stream
-	 */
-	public static <T> ObjectLinkedList KEY_GENERIC_TYPE toList(Stream<T> stream) {
-		return stream.collect(ObjectLinkedList::new, ObjectLinkedList::add, ObjectLinkedList::merge);
-	}
-	
-	private ObjectLinkedList<T> merge(ObjectLinkedList<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a LinkedList
-	 * @return a list with the contents of the Stream
-	 */
-	public static LINKED_LIST toList(JAVA_STREAM stream) {
-		return stream.collect(LINKED_LIST::new, LINKED_LIST::add, LINKED_LIST::addAll);
-	}
-	
-#endif
-#endif
 	@Override
 	public boolean add(KEY_TYPE e) {
 		add(size(), e);
@@ -466,8 +415,7 @@ 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.
@@ -488,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);
@@ -540,12 +487,12 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
-			if(filter.test(entry.value)) return OPTIONAL.GET_OPTIONAL(entry.value);
+			if(filter.test(entry.value)) return entry.value;
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 #if !TYPE_OBJECT
@@ -572,7 +519,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -584,7 +531,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			}
 			state = operator.APPLY_VALUE(state, entry.value);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
@@ -1306,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;
@@ -1451,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,10 +15,7 @@ import java.util.function.UnaryOperator;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
-import speiger.src.collections.PACKAGE.collections.ORDERED_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;
@@ -30,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
@@ -41,7 +36,7 @@ import speiger.src.collections.utils.SanityChecks;
  * A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
  * @Type(T)
  */
-public interface LIST KEY_GENERIC_TYPE extends ORDERED_COLLECTION KEY_GENERIC_TYPE, List<CLASS_TYPE>
+public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List<CLASS_TYPE>
 {
 #if !TYPE_OBJECT
 	/**
@@ -106,24 +101,6 @@ public interface LIST KEY_GENERIC_TYPE extends ORDERED_COLLECTION KEY_GENERIC_TY
 	 */
 	public boolean addAll(int index, LIST KEY_GENERIC_TYPE c);
 	
-	/**
-	 * A method to add an element to the start of a list
-	 * @param e that should be added at the start.
-	 */
-	@Override
-	public default void addFirst(KEY_TYPE e) { 
-		add(0, e);
-	}
-	
-	/**
-	 * A method to add an element to the end of a list
-	 * @param e that should be added at the end.
-	 */
-	@Override
-	public default void addLast(KEY_TYPE e) {
-		add(e);
-	}
-	
 	/**
 	 * Helper method that returns the first element of a List.
 	 * This function was introduced due to how annoying it is to get/remove the last element of a list.
@@ -527,56 +504,9 @@ public interface LIST KEY_GENERIC_TYPE extends ORDERED_COLLECTION KEY_GENERIC_TY
 	@Override
 	@Deprecated
 	public default boolean add(CLASS_TYPE e) {
-		return ORDERED_COLLECTION.super.add(e);
+		return COLLECTION.super.add(e);
-	}
-
-#if JAVA_VERSION>=21
-#if !TYPE_OBJECT
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void addFirst(CLASS_TYPE e) {
-		addFirst(OBJ_TO_KEY(e));
-	}
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void addLast(CLASS_TYPE e) {
-		addLast(OBJ_TO_KEY(e));
 	}
 	
-#endif
-	@Override
-	@Deprecated
-	default CLASS_TYPE getFirst() {
-		return KEY_TO_OBJ(GET_FIRST_KEY());
-	}
-	
-	@Override
-	@Deprecated
-	default CLASS_TYPE getLast() {
-		return KEY_TO_OBJ(GET_LAST_KEY());
-	}
-	
-	@Override
-	@Deprecated
-	default CLASS_TYPE removeFirst() {
-		return KEY_TO_OBJ(REMOVE_FIRST_KEY());
-	}
-	
-	@Override
-	@Deprecated
-	default CLASS_TYPE removeLast() {
-		return KEY_TO_OBJ(REMOVE_LAST_KEY());
-	}
-	
-#endif
 	/** {@inheritDoc}
 	 * <p>This default implementation delegates to the corresponding type-specific function.
 	 * @deprecated Please use the corresponding type-specific function instead. 
@@ -624,7 +554,7 @@ public interface LIST KEY_GENERIC_TYPE extends ORDERED_COLLECTION KEY_GENERIC_TY
 	@Override
 	@Deprecated
 	public default boolean contains(Object o) {
-		return ORDERED_COLLECTION.super.contains(o);
+		return COLLECTION.super.contains(o);
 	}
 	
 	/** {@inheritDoc}
@@ -634,7 +564,7 @@ public interface LIST KEY_GENERIC_TYPE extends ORDERED_COLLECTION KEY_GENERIC_TY
 	@Override
 	@Deprecated
 	public default boolean remove(Object o) {
-		return ORDERED_COLLECTION.super.remove(o);
+		return COLLECTION.super.remove(o);
 	}
 	
 	/** {@inheritDoc}
@@ -664,12 +594,10 @@ public interface LIST KEY_GENERIC_TYPE extends ORDERED_COLLECTION KEY_GENERIC_TY
 	}
 #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/maps/abstracts/AbstractMap.template

@@ -14,15 +14,6 @@ import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 #endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-#if ORDERED_MAP_FEATURE
-import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
-import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
-import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
-#if !TYPE_OBJECT
-import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectOrderedSet;
-#endif
-#endif
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
 #if MAPS_FEATURE
@@ -51,7 +42,7 @@ import speiger.src.collections.utils.SanityChecks;
  */
 public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CLASS_TYPE, CLASS_VALUE_TYPE> implements MAP KEY_VALUE_GENERIC_TYPE
 {
-	protected VALUE_TYPE defaultReturnValue = INVALID_VALUE;
+	protected VALUE_TYPE defaultReturnValue = EMPTY_VALUE;
 	
 	@Override
 	public VALUE_TYPE getDefaultReturnValue() {
@@ -128,7 +119,7 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 	public void putAll(CLASS_TYPE[] keys, CLASS_VALUE_TYPE[] values, int offset, int size) {
 		SanityChecks.checkArrayCapacity(keys.length, offset, size);
 		SanityChecks.checkArrayCapacity(values.length, offset, size);
-		for(int i = 0;i<size;i++) put(OBJ_TO_KEY(keys[i]), OBJ_TO_VALUE(values[i]));		
+		for(int i = 0;i<size;i++) put(keys[i], values[i]);		
 	}
 	
 #endif
@@ -552,132 +543,6 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 		return hash;
 	}
 	
-	public static class REVERSED_ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE {
-		ORDERED_MAP KEY_VALUE_GENERIC_TYPE map;
-		
-		public REVERSED_ORDERED_MAP(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map) {
-			this.map = map;
-		}
-		@Override
-		public ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE setDefaultReturnValue(VALUE_TYPE v) {
-			map.setDefaultReturnValue(v);
-			return this;
-		}
-		@Override
-		public VALUE_TYPE getDefaultReturnValue() { return map.getDefaultReturnValue(); }
-		@Override
-		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) { return map.put(key, value); }
-		@Override
-		public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) { return map.putIfAbsent(key, value); }
-#if VALUE_PRIMITIVES
-		@Override
-		public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { return map.addTo(key, value); }
-		@Override
-		public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { return map.subFrom(key, value); }
-#endif
-		@Override
-		public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { return map.REMOVE_VALUE(key); }
-#if !TYPE_OBJECT || !VALUE_OBJECT
-		@Override
-		public boolean remove(KEY_TYPE key, VALUE_TYPE value) { return map.remove(key, value); }
-#endif
-		@Override
-		public VALUE_TYPE REMOVE_VALUEOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.REMOVE_VALUEOrDefault(key, defaultValue); }
-		@Override
-#if TYPE_OBJECT
-		public boolean containsKey(Object key) { return map.containsKey(key); }
-#else
-		public boolean containsKey(KEY_TYPE key) { return map.containsKey(key); }
-#endif
-		@Override
-#if VALUE_OBJECT
-		public boolean containsValue(Object value) { return map.containsValue(value); }
-#else
-		public boolean containsValue(VALUE_TYPE value) { return map.containsValue(value); }
-#endif
-		@Override
-		public boolean replace(KEY_TYPE key, VALUE_TYPE oldValue, VALUE_TYPE newValue) { return map.replace(key, oldValue, newValue); }
-		@Override
-		public VALUE_TYPE replace(KEY_TYPE key, VALUE_TYPE value) { return map.replace(key, value); }
-		@Override
-		public void REPLACE_VALUES(MAP KEY_VALUE_GENERIC_TYPE m) { map.REPLACE_VALUES(m); }
-		@Override
-		public void REPLACE_VALUES(UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { map.REPLACE_VALUES(mappingFunction); }
-		@Override
-		public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE(key, mappingFunction); }
-		@Override
-		public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE_IF_ABSENT(key, mappingFunction); }
-		@Override
-		public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) { return map.SUPPLY_IF_ABSENT(key, valueProvider); }
-		@Override
-		public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE_IF_PRESENT(key, mappingFunction); }
-#if !VALUE_OBJECT
-		@Override
-		public VALUE_TYPE COMPUTENonDefault(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTENonDefault(key, mappingFunction); }
-		@Override
-		public VALUE_TYPE COMPUTE_IF_ABSENTNonDefault(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE_IF_ABSENTNonDefault(key, mappingFunction); }
-		@Override
-		public VALUE_TYPE SUPPLY_IF_ABSENTNonDefault(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) { return map.SUPPLY_IF_ABSENTNonDefault(key, valueProvider); }
-		@Override
-		public VALUE_TYPE COMPUTE_IF_PRESENTNonDefault(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE_IF_PRESENTNonDefault(key, mappingFunction); }
-#endif
-		@Override
-		public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { return map.MERGE(key, value, mappingFunction); }
-#if !TYPE_OBJECT || !VALUE_OBJECT
-		@Override
-		public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.getOrDefault(key, defaultValue); }
-#endif
-		@Override
-		public VALUE_TYPE GET_VALUE(KEY_TYPE key) { return map.GET_VALUE(key); }
-		@Override
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { return map.putAndMoveToLast(key, value); }
-		@Override
-		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { return map.putAndMoveToFirst(key, value); }
-		@Override
-		public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { return map.putLast(key, value); }
-		@Override
-		public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { return map.putFirst(key, value); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE key) { return map.moveToLast(key); }
-		@Override
-		public boolean moveToLast(KEY_TYPE key) { return map.moveToFirst(key); }
-		@Override
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { return map.getAndMoveToLast(key); }
-		@Override
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { return map.getAndMoveToFirst(key); }
-		@Override
-		public KEY_TYPE FIRST_ENTRY_KEY() { return map.LAST_ENTRY_KEY(); }
-		@Override
-		public KEY_TYPE POLL_FIRST_ENTRY_KEY() { return map.POLL_LAST_ENTRY_KEY(); }
-		@Override
-		public KEY_TYPE LAST_ENTRY_KEY() { return map.FIRST_ENTRY_KEY(); }
-		@Override
-		public KEY_TYPE POLL_LAST_ENTRY_KEY() { return map.POLL_FIRST_ENTRY_KEY(); }
-		@Override
-		public VALUE_TYPE FIRST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); }
-		@Override
-		public VALUE_TYPE LAST_ENTRY_VALUE() { return map.FIRST_ENTRY_VALUE(); }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { return map.lastEntry(); }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { return map.firstEntry(); }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { return map.pollLastEntry(); }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { return map.pollFirstEntry(); }
-		@Override
-		public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.ENTRY_SET()); }
-		@Override
-		public ORDERED_SET KEY_GENERIC_TYPE keySet() { return new ABSTRACT_SET.REVERSED_ORDERED_SETBRACES(map.keySet()); }
-		@Override
-		public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() { return map.values().reversed(); }
-		@Override
-		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE reversed() { return map; }
-	}
-
-	
 	/**
 	 * A Simple Type Specific Entry class to reduce boxing/unboxing
 	 * @Type(T)

src/builder/resources/speiger/assets/collections/templates/maps/impl/concurrent/ConcurrentOpenHashMap.template

@@ -4,18 +4,15 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.concurrent.locks.StampedLock;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.function.BiFunction;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 #if !TYPE_OBJECT
@@ -43,12 +40,9 @@ import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 #endif
-#if !TYPE_OBJECT && !JDK_TYPE
+#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#if!VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#endif
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.CONCURRENT_MAP;
@@ -84,7 +78,6 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if VALUE_OBJECT
@@ -846,7 +839,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -870,11 +863,11 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
 			MapEntry entry = new MapEntry();
 			for(int i = 0,m=segments.length;i<m;i++) {
@@ -884,7 +877,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 				try {
 					while(index != -1) {
 						entry.set(index, i);
-						if(filter.test(entry)) return Optional.ofNullable(entry);
+						if(filter.test(entry)) return entry;
 						index = (int)seg.links[index];
 					}
 				}
@@ -892,7 +885,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override
@@ -1193,7 +1186,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1217,11 +1210,11 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(int i = 0,m=segments.length;i<m;i++) {
 				Segment KEY_VALUE_GENERIC_TYPE seg = segments[i];
@@ -1229,7 +1222,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 				try {
 					int index = seg.firstIndex;
 					while(index != -1){
-						if(filter.test(seg.keys[index])) return OPTIONAL.GET_OPTIONAL(seg.keys[index]);
+						if(filter.test(seg.keys[index])) return seg.keys[index];
 						index = (int)seg.links[index];
 					}
 				}
@@ -1237,7 +1230,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -1461,7 +1454,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		
 #endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1485,20 +1478,20 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return VALUE_OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_VALUE;
 			for(int i = 0,m=segments.length;i<m;i++) {
 				Segment KEY_VALUE_GENERIC_TYPE seg = segments[i];
 				long stamp = seg.readLock();
 				try {
 					int index = seg.firstIndex;
 					while(index != -1){
-						if(filter.test(seg.values[index])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(seg.values[index]);
+						if(filter.test(seg.values[index])) return seg.values[index];
 						index = (int)seg.links[index];
 					}
 				}
@@ -1506,7 +1499,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override

src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template

@@ -4,17 +4,14 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
@@ -30,7 +27,6 @@ import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
 #if !TYPE_OBJECT && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
 #if !TYPE_INT || !SAME_TYPE
@@ -44,7 +40,7 @@ import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.utils.STRATEGY;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
-import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
+import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
@@ -63,7 +59,6 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT
@@ -238,13 +233,13 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			if(containsNull) {
 				VALUE_TYPE lastValue = values[nullIndex];
 				values[nullIndex] = value;
-				moveToFirstIndex(nullIndex, false);
+				moveToFirstIndex(nullIndex);
 				return lastValue;
 			}
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex, true);
+			moveToFirstIndex(nullIndex);
 		}
 		else {
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
@@ -252,7 +247,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				if(strategy.equals(keys[pos], key)) {
 					VALUE_TYPE lastValue = values[pos];
 					values[pos] = value;
-					moveToFirstIndex(pos, false);
+					moveToFirstIndex(pos);
 					return lastValue;
 				}
 				pos = ++pos & mask;
@@ -260,7 +255,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToFirstIndex(pos, true);
+			moveToFirstIndex(pos);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -272,13 +267,13 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			if(containsNull) {
 				VALUE_TYPE lastValue = values[nullIndex];
 				values[nullIndex] = value;
-				moveToLastIndex(nullIndex, false);
+				moveToLastIndex(nullIndex);
 				return lastValue;
 			}
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToLastIndex(nullIndex, true);
+			moveToLastIndex(nullIndex);
 		}
 		else {
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
@@ -286,7 +281,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				if(strategy.equals(keys[pos], key)) {
 					VALUE_TYPE lastValue = values[pos];
 					values[pos] = value;
-					moveToLastIndex(pos, false);
+					moveToLastIndex(pos);
 					return lastValue;
 				}
 				pos = ++pos & mask;
@@ -294,55 +289,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToLastIndex(pos, true);
+			moveToLastIndex(pos);
-		}
-		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
-		return getDefaultReturnValue();
-	}
-	
-	@Override
-	public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) {
-		if(strategy.equals(key, EMPTY_KEY_VALUE)) {
-			if(containsNull) return values[nullIndex];
-			values[nullIndex] = value;
-			containsNull = true;
-			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex, true);
-		}
-		else {
-			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
-			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
-				if(strategy.equals(keys[pos], key)) return values[pos];
-				pos = ++pos & mask;
-			}
-			keys[pos] = key;
-			values[pos] = value;
-			onNodeAdded(pos);
-			moveToFirstIndex(pos, true);
-		}
-		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
-		return getDefaultReturnValue();
-	}
-	
-	@Override
-	public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) {
-		if(strategy.equals(key, EMPTY_KEY_VALUE)) {
-			if(containsNull) return values[nullIndex];
-			values[nullIndex] = value;
-			containsNull = true;
-			onNodeAdded(nullIndex);
-			moveToLastIndex(nullIndex, true);
-		}
-		else {
-			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
-			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
-				if(strategy.equals(keys[pos], key)) return values[pos];
-				pos = ++pos & mask;
-			}
-			keys[pos] = key;
-			values[pos] = value;
-			onNodeAdded(pos);
-			moveToLastIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -353,7 +300,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		if(isEmpty() || strategy.equals(FIRST_ENTRY_KEY(), key)) return false;
 		if(strategy.equals(key, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
-				moveToFirstIndex(nullIndex, false);
+				moveToFirstIndex(nullIndex);
 				return true;
 			}
 		}
@@ -361,7 +308,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
 			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
 				if(strategy.equals(keys[pos], key)) {
-					moveToFirstIndex(pos, false);
+					moveToFirstIndex(pos);
 					return true;
 				}
 				pos = ++pos & mask;
@@ -375,7 +322,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		if(isEmpty() || strategy.equals(LAST_ENTRY_KEY(), key)) return false;
 		if(strategy.equals(key, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
-				moveToLastIndex(nullIndex, false);
+				moveToLastIndex(nullIndex);
 				return true;
 			}
 		}
@@ -383,7 +330,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
 			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
 				if(strategy.equals(keys[pos], key)) {
-					moveToLastIndex(pos, false);
+					moveToLastIndex(pos);
 					return true;
 				}
 				pos = ++pos & mask;
@@ -396,7 +343,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) {
 		int index = findIndex(key);
 		if(index < 0) return getDefaultReturnValue();
-		moveToFirstIndex(index, false);
+		moveToFirstIndex(index);
 		return values[index];
 	}
 	
@@ -404,7 +351,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) {
 		int index = findIndex(key);
 		if(index < 0) return getDefaultReturnValue();
-		moveToLastIndex(index, false);
+		moveToLastIndex(index);
 		return values[index];
 	}
 	
@@ -483,52 +430,6 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		return values[lastIndex];
 	}
 	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		int pos = firstIndex;
-		onNodeRemoved(pos);
-		BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
-		size--;
-		if(strategy.equals(result.ENTRY_KEY(), EMPTY_KEY_VALUE)) {
-			containsNull = false;
-			keys[nullIndex] = EMPTY_KEY_VALUE;
-			values[nullIndex] = EMPTY_VALUE;
-		}
-		else shiftKeys(pos);
-		if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2);
-		return result;
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		int pos = lastIndex;
-		onNodeRemoved(pos);
-		BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
-		size--;
-		if(strategy.equals(result.ENTRY_KEY(), EMPTY_KEY_VALUE)) {
-			containsNull = false;
-			keys[nullIndex] = EMPTY_KEY_VALUE;
-			values[nullIndex] = EMPTY_VALUE;
-		}
-		else shiftKeys(pos);
-		if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2);
-		return result;
-	}
-	
 	@Override
 	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
@@ -542,9 +443,9 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	}
 	
 	@Override
-	public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
+	public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
 		if(valuesC == null) valuesC = new Values();
-		return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
+		return valuesC;
 	}
 	
 	@Override
@@ -580,8 +481,8 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		containsNull = false;
 	}
 	
-	protected void moveToFirstIndex(int startPos, boolean adding) {
+	protected void moveToFirstIndex(int startPos) {
-		if(size == (adding ? 0 : 1) || firstIndex == startPos) return;
+		if(size == 1 || firstIndex == startPos) return;
 		if(lastIndex == startPos) {
 			lastIndex = (int)(links[startPos] >>> 32);
 			links[lastIndex] |= 0xFFFFFFFFL;
@@ -598,8 +499,8 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		firstIndex = startPos;
 	}
 	
-	protected void moveToLastIndex(int startPos, boolean adding) {
+	protected void moveToLastIndex(int startPos) {
-		if(size == (adding ? 0 : 1) || lastIndex == startPos) return;
+		if(size == 1 || lastIndex == startPos) return;
 		if(firstIndex == startPos) {
 			firstIndex = (int)links[startPos];
 			links[lastIndex] |= 0xFFFFFFFF00000000L;
@@ -713,10 +614,6 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
-		@Override
-		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -733,24 +630,24 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
 			return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
 			return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() {
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 			POLL_FIRST_ENTRY_KEY();
 			return entry;
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() {
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 			POLL_LAST_ENTRY_KEY();
 			return entry;
@@ -758,12 +655,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
-			return new EntryIterator(true);
+			return new EntryIterator();
-		}
-		
-		@Override
-		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
-			return new EntryIterator(false);
 		}
 		
 		@Override
@@ -773,7 +665,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
-			return new FastEntryIterator(true);
+			return new FastEntryIterator();
 		}
 		
 		@Override
@@ -882,7 +774,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -897,21 +789,21 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				state = operator.apply(state, new ValueMapEntry(index));
 				index = (int)links[index];
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return Optional.empty();
+			if(size() <= 0) return null;
 			MapEntry entry = new MapEntry();
 			int index = firstIndex;
 			while(index != -1) {
 				entry.set(index);
-				if(filter.test(entry)) return Optional.ofNullable(entry);
+				if(filter.test(entry)) return entry;
 				index = (int)links[index];
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override
@@ -1008,13 +900,10 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		public boolean add(KEY_TYPE o) {
 			throw new UnsupportedOperationException();
 		}
-
+		
-		@Override
-		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }		
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+
 		@Override
 		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 
@@ -1030,12 +919,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		
 		@Override
 		public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
-			return new KeyIterator(true);
+			return new KeyIterator();
-		}
-		
-		@Override
-		public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-			return new KeyIterator(false);
 		}
 		
 		@Override
@@ -1057,22 +941,22 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		}
 		
 		@Override
-		public KEY_TYPE GET_FIRST_KEY() {
+		public KEY_TYPE FIRST_KEY() {
 			return FIRST_ENTRY_KEY();
 		}
 		
 		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() {
+		public KEY_TYPE POLL_FIRST_KEY() {
 			return POLL_FIRST_ENTRY_KEY();
 		}
 
 		@Override
-		public KEY_TYPE GET_LAST_KEY() {
+		public KEY_TYPE LAST_KEY() {
 			return LAST_ENTRY_KEY();
 		}
 
 		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() {
+		public KEY_TYPE POLL_LAST_KEY() {
 			return POLL_LAST_ENTRY_KEY();
 		}
 		
@@ -1172,7 +1056,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1187,19 +1071,19 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				state = operator.APPLY_KEY_VALUE(state, keys[index]);
 				index = (int)links[index];
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_KEY_VALUE;
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
+				if(filter.test(keys[index])) return keys[index];
 				index = (int)links[index];
 			}
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -1216,47 +1100,39 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		}
 	}
 	
-	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
+	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
 #if VALUE_OBJECT
 		@Override
 		@Deprecated
-		public boolean contains(Object e) { return containsValue(e); }
+		public boolean contains(Object e) {
+			return containsValue(e);
+		}
+		
 #else
 		@Override
-		public boolean contains(VALUE_TYPE e) { return containsValue(e); }
+		public boolean contains(VALUE_TYPE e) {
+			return containsValue(e);
+		}
+		
 #endif
 		@Override
-		public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
+		public boolean add(VALUE_TYPE o) {
-		@Override
+			throw new UnsupportedOperationException();
-		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
-		@Override
-		public int size() { return LINKED_CUSTOM_HASH_MAP.this.size(); }
-		@Override
-		public void clear() { LINKED_CUSTOM_HASH_MAP.this.clear(); }
-		@Override
-		public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
-		private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
-			return new ValueIterator(false);
 		}
+
 		@Override
-		public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
+		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
-		@Override
+			return new ValueIterator();
-		public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
-		@Override
-		public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() {
-			VALUE_TYPE result = FIRST_ENTRY_VALUE();
-			POLL_FIRST_ENTRY_KEY();
-			return result; 
 		}
+		
 		@Override
-		public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
+		public int size() {
+			return LINKED_CUSTOM_HASH_MAP.this.size();
+		}
+		
 		@Override
-		public VALUE_TYPE VALUE_REMOVE_LAST_KEY() {
+		public void clear() {
-			VALUE_TYPE result = LAST_ENTRY_VALUE();
+			LINKED_CUSTOM_HASH_MAP.this.clear();
-			POLL_LAST_ENTRY_KEY();
-			return result; 
 		}
 		
 		@Override
@@ -1355,7 +1231,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		
 #endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1370,19 +1246,19 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				state = operator.APPLY_VALUE(state, values[index]);
 				index = (int)links[index];
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return VALUE_OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_VALUE;
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(values[index])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[index]);
+				if(filter.test(values[index])) return values[index];
 				index = (int)links[index];
 			}
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override
@@ -1402,7 +1278,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry = new MapEntry();
 		
-		public FastEntryIterator(boolean start) { super(start); }
+		public FastEntryIterator() {}
 		public FastEntryIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1429,7 +1305,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry;
 		
-		public EntryIterator(boolean start) { super(start); }
+		public EntryIterator() {}
 		public EntryIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1459,7 +1335,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	
 	private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		
-		public KeyIterator(boolean start) { super(start); }
+		public KeyIterator() {}
 		public KeyIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1481,7 +1357,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	}
 	
 	private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
-		public ValueIterator(boolean start) { super(start); }
+		public ValueIterator() {}
 		
 		@Override
 		public VALUE_TYPE VALUE_PREVIOUS() {
@@ -1502,20 +1378,16 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	}
 	
 	private class MapIterator {
-		boolean forward;
 		int previous = -1;
 		int next = -1;
 		int current = -1;
 		int index = 0;
 		
-		MapIterator(boolean start) {
+		MapIterator() {
-			this.forward = start;
+			next = firstIndex;
-			if(start) next = firstIndex;
-			else previous = lastIndex;
 		}
 		
 		MapIterator(KEY_TYPE from) {
-			this.forward = true;
 			if(strategy.equals(from, EMPTY_KEY_VALUE)) {
 				if(containsNull) {
 					next = (int) links[nullIndex];
@@ -1543,11 +1415,11 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		}
 		
 		public boolean hasNext() {
-			return (forward ? next : previous) != -1;
+			return next != -1;
 		}
 
 		public boolean hasPrevious() {
-			return (forward ? previous : next) != -1;
+			return previous != -1;
 		}
 		
 		public int nextIndex() {
@@ -1607,30 +1479,20 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		
 		public int previousEntry() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) moveBackwards();
+			current = previous;
-			else moveForwards();
+			previous = (int)(links[current] >> 32);
+			next = current;
 			if(index >= 0) index--;
 			return current;
 		}
 		
 		public int nextEntry() {
 			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) moveForwards();
-			else moveBackwards();
-			if(index >= 0) index++;
-			return current;
-		}
-		
-		private void moveBackwards() {
-			current = previous;
-			previous = (int)(links[current] >> 32);
-			next = current;
-		}
-		
-		private void moveForwards() {
 			current = next;
 			next = (int)(links[current]);
 			previous = current;
+			if(index >= 0) index++;
+			return current;
 		}
 		
 		private void ensureIndexKnown() {

src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/OpenCustomHashMap.template

@@ -5,17 +5,14 @@ import java.util.ConcurrentModificationException;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 #if !TYPE_OBJECT
@@ -40,12 +37,9 @@ import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 #endif
-#if !TYPE_OBJECT && !JDK_TYPE
+#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#if !VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#endif
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 #if !TYPE_OBJECT
@@ -81,7 +75,6 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 import speiger.src.collections.objects.collections.ObjectIterator;
@@ -1097,7 +1090,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -1114,25 +1107,25 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				}
 				state = operator.apply(state, new ValueMapEntry(i));
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return Optional.empty();
+			if(size() <= 0) return null;
 			MapEntry entry = new MapEntry();
 			if(containsNull) {
 				entry.set(nullIndex);
-				if(filter.test(entry)) return Optional.ofNullable(entry);
+				if(filter.test(entry)) return entry;
 			}
 			for(int i = nullIndex-1;i>=0;i--) {
 				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE)) {
 					entry.set(i);
-					if(filter.test(entry)) return Optional.ofNullable(entry);
+					if(filter.test(entry)) return entry;
 				}
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override
@@ -1338,7 +1331,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1355,18 +1348,18 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				}
 				state = operator.APPLY_KEY_VALUE(state, keys[i]);
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_KEY_VALUE;
-			if(containsNull && filter.test(keys[nullIndex])) return OPTIONAL.GET_OPTIONAL(keys[nullIndex]);
+			if(containsNull && filter.test(keys[nullIndex])) return keys[nullIndex];
 			for(int i = nullIndex-1;i>=0;i--) {
-				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
+				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(keys[i])) return keys[i];
 			}
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -1504,7 +1497,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		
 #endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1521,18 +1514,18 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				}
 				state = operator.APPLY_VALUE(state, values[i]);
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return VALUE_OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_VALUE;
-			if(containsNull && filter.test(values[nullIndex])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[nullIndex]);
+			if(containsNull && filter.test(values[nullIndex])) return values[nullIndex];
 			for(int i = nullIndex-1;i>=0;i--) {
-				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(values[i])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[i]);
+				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(values[i])) return values[i];
 			}
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override

src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template

@@ -4,17 +4,14 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
@@ -30,7 +27,6 @@ import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
 #if !TYPE_OBJECT && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
 #if !TYPE_INT || !SAME_TYPE
@@ -43,7 +39,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
-import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
+import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
@@ -62,7 +58,6 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT
@@ -215,13 +210,13 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			if(containsNull) {
 				VALUE_TYPE lastValue = values[nullIndex];
 				values[nullIndex] = value;
-				moveToFirstIndex(nullIndex, false);
+				moveToFirstIndex(nullIndex);
 				return lastValue;
 			}
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex, true);
+			moveToFirstIndex(nullIndex);
 		}
 		else {
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
@@ -229,7 +224,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				if(KEY_EQUALS(keys[pos], key)) {
 					VALUE_TYPE lastValue = values[pos];
 					values[pos] = value;
-					moveToFirstIndex(pos, false);
+					moveToFirstIndex(pos);
 					return lastValue;
 				}
 				pos = ++pos & mask;
@@ -237,7 +232,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToFirstIndex(pos, true);
+			moveToFirstIndex(pos);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -249,13 +244,13 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			if(containsNull) {
 				VALUE_TYPE lastValue = values[nullIndex];
 				values[nullIndex] = value;
-				moveToLastIndex(nullIndex, false);
+				moveToLastIndex(nullIndex);
 				return lastValue;
 			}
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToLastIndex(nullIndex, true);
+			moveToLastIndex(nullIndex);
 		}
 		else {
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
@@ -263,7 +258,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				if(KEY_EQUALS(keys[pos], key)) {
 					VALUE_TYPE lastValue = values[pos];
 					values[pos] = value;
-					moveToLastIndex(pos, false);
+					moveToLastIndex(pos);
 					return lastValue;
 				}
 				pos = ++pos & mask;
@@ -271,55 +266,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToLastIndex(pos, true);
+			moveToLastIndex(pos);
-		}
-		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
-		return getDefaultReturnValue();
-	}
-	
-	@Override
-	public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) {
-		if(KEY_EQUALS_NULL(key)) {
-			if(containsNull) return values[nullIndex];
-			values[nullIndex] = value;
-			containsNull = true;
-			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex, true);
-		}
-		else {
-			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
-			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
-				if(KEY_EQUALS(keys[pos], key)) return values[pos];
-				pos = ++pos & mask;
-			}
-			keys[pos] = key;
-			values[pos] = value;
-			onNodeAdded(pos);
-			moveToFirstIndex(pos, true);
-		}
-		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
-		return getDefaultReturnValue();
-	}
-	
-	@Override
-	public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) {
-		if(KEY_EQUALS_NULL(key)) {
-			if(containsNull) return values[nullIndex];
-			values[nullIndex] = value;
-			containsNull = true;
-			onNodeAdded(nullIndex);
-			moveToLastIndex(nullIndex, true);
-		}
-		else {
-			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
-			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
-				if(KEY_EQUALS(keys[pos], key)) return values[pos];
-				pos = ++pos & mask;
-			}
-			keys[pos] = key;
-			values[pos] = value;
-			onNodeAdded(pos);
-			moveToLastIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -330,7 +277,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		if(isEmpty() || KEY_EQUALS(FIRST_ENTRY_KEY(), key)) return false;
 		if(KEY_EQUALS_NULL(key)) {
 			if(containsNull) {
-				moveToFirstIndex(nullIndex, false);
+				moveToFirstIndex(nullIndex);
 				return true;
 			}
 		}
@@ -338,7 +285,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
 			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
 				if(KEY_EQUALS(keys[pos], key)) {
-					moveToFirstIndex(pos, false);
+					moveToFirstIndex(pos);
 					return true;
 				}
 				pos = ++pos & mask;
@@ -352,7 +299,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		if(isEmpty() || KEY_EQUALS(LAST_ENTRY_KEY(), key)) return false;
 		if(KEY_EQUALS_NULL(key)) {
 			if(containsNull) {
-				moveToLastIndex(nullIndex, false);
+				moveToLastIndex(nullIndex);
 				return true;
 			}
 		}
@@ -360,7 +307,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
 			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
 				if(KEY_EQUALS(keys[pos], key)) {
-					moveToLastIndex(pos, false);
+					moveToLastIndex(pos);
 					return true;
 				}
 				pos = ++pos & mask;
@@ -373,7 +320,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) {
 		int index = findIndex(key);
 		if(index < 0) return getDefaultReturnValue();
-		moveToFirstIndex(index, false);
+		moveToFirstIndex(index);
 		return values[index];
 	}
 	
@@ -381,7 +328,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) {
 		int index = findIndex(key);
 		if(index < 0) return getDefaultReturnValue();
-		moveToLastIndex(index, false);
+		moveToLastIndex(index);
 		return values[index];
 	}
 	
@@ -487,52 +434,6 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		return values[lastIndex];
 	}
 	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		int pos = firstIndex;
-		onNodeRemoved(pos);
-		BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
-		size--;
-		if(KEY_EQUALS_NULL(result.ENTRY_KEY())) {
-			containsNull = false;
-			keys[nullIndex] = EMPTY_KEY_VALUE;
-			values[nullIndex] = EMPTY_VALUE;
-		}
-		else shiftKeys(pos);
-		if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2);
-		return result;
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		int pos = lastIndex;
-		onNodeRemoved(pos);
-		BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
-		size--;
-		if(KEY_EQUALS_NULL(result.ENTRY_KEY())) {
-			containsNull = false;
-			keys[nullIndex] = EMPTY_KEY_VALUE;
-			values[nullIndex] = EMPTY_VALUE;
-		}
-		else shiftKeys(pos);
-		if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2);
-		return result;
-	}
-	
 	@Override
 	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
@@ -546,9 +447,9 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	}
 	
 	@Override
-	public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
+	public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
 		if(valuesC == null) valuesC = new Values();
-		return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
+		return valuesC;
 	}
 	
 	@Override
@@ -584,8 +485,8 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		containsNull = false;
 	}
 	
-	protected void moveToFirstIndex(int startPos, boolean adding) {
+	protected void moveToFirstIndex(int startPos) {
-		if(size == (adding ? 0 : 1) || firstIndex == startPos) return;
+		if(size == 1 || firstIndex == startPos) return;
 		if(lastIndex == startPos) {
 			lastIndex = (int)(links[startPos] >>> 32);
 			links[lastIndex] |= 0xFFFFFFFFL;
@@ -602,8 +503,8 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		firstIndex = startPos;
 	}
 	
-	protected void moveToLastIndex(int startPos, boolean adding) {
+	protected void moveToLastIndex(int startPos) {
-		if(size == (adding ? 0 : 1) || lastIndex == startPos) return;
+		if(size == 1 || lastIndex == startPos) return;
 		if(firstIndex == startPos) {
 			firstIndex = (int)links[startPos];
 			links[lastIndex] |= 0xFFFFFFFF00000000L;
@@ -717,10 +618,6 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
-		@Override
-		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -737,24 +634,24 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
 			return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
 			return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() {
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 			POLL_FIRST_ENTRY_KEY();
 			return entry;
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() {
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 			POLL_LAST_ENTRY_KEY();
 			return entry;
@@ -762,12 +659,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
-			return new EntryIterator(true);
+			return new EntryIterator();
-		}
-		
-		@Override
-		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
-			return new EntryIterator(false);
 		}
 		
 		@Override
@@ -777,7 +669,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
-			return new FastEntryIterator(true);
+			return new FastEntryIterator();
 		}
 		
 		@Override
@@ -886,7 +778,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -901,21 +793,21 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				state = operator.apply(state, new ValueMapEntry(index));
 				index = (int)links[index];
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return Optional.empty();
+			if(size() <= 0) return null;
 			MapEntry entry = new MapEntry();
 			int index = firstIndex;
 			while(index != -1) {
 				entry.set(index);
-				if(filter.test(entry)) return Optional.ofNullable(entry);
+				if(filter.test(entry)) return entry;
 				index = (int)links[index];
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override
@@ -1007,12 +899,6 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 #endif
 		@Override
 		public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
-		@Override
-		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
@@ -1032,12 +918,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 		@Override
 		public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
-			return new KeyIterator(true);
+			return new KeyIterator();
-		}
-		
-		@Override
-		public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-			return new KeyIterator(false);
 		}
 		
 		@Override
@@ -1059,22 +940,22 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		}
 		
 		@Override
-		public KEY_TYPE GET_FIRST_KEY() {
+		public KEY_TYPE FIRST_KEY() {
 			return FIRST_ENTRY_KEY();
 		}
 		
 		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() {
+		public KEY_TYPE POLL_FIRST_KEY() {
 			return POLL_FIRST_ENTRY_KEY();
 		}
 
 		@Override
-		public KEY_TYPE GET_LAST_KEY() {
+		public KEY_TYPE LAST_KEY() {
 			return LAST_ENTRY_KEY();
 		}
 
 		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() {
+		public KEY_TYPE POLL_LAST_KEY() {
 			return POLL_LAST_ENTRY_KEY();
 		}
 		
@@ -1174,7 +1055,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1189,19 +1070,19 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				state = operator.APPLY_KEY_VALUE(state, keys[index]);
 				index = (int)links[index];
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_KEY_VALUE;
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
+				if(filter.test(keys[index])) return keys[index];
 				index = (int)links[index];
 			}
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -1218,50 +1099,41 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		}
 	}
 	
-	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
+	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
 #if VALUE_OBJECT
 		@Override
 		@Deprecated
-		public boolean contains(Object e) { return containsValue(e); }
+		public boolean contains(Object e) {
+			return containsValue(e);
+		}
 		
 #else
 		@Override
-		public boolean contains(VALUE_TYPE e) { return containsValue(e); }
+		public boolean contains(VALUE_TYPE e) {
+			return containsValue(e);
+		}
 		
 #endif
 		@Override
-		public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
+		public boolean add(VALUE_TYPE o) {
-		@Override
+			throw new UnsupportedOperationException();
-		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
-		@Override
-		public int size() { return LINKED_HASH_MAP.this.size(); }
-		@Override
-		public void clear() { LINKED_HASH_MAP.this.clear(); }
-		@Override
-		public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
-		private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
-			return new ValueIterator(false);
 		}
+
 		@Override
-		public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
+		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
-		@Override
+			return new ValueIterator();
-		public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
-		@Override
-		public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() {
-			VALUE_TYPE result = FIRST_ENTRY_VALUE();
-			POLL_FIRST_ENTRY_KEY();
-			return result; 
 		}
+		
 		@Override
-		public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
+		public int size() {
-		@Override
+			return LINKED_HASH_MAP.this.size();
-		public VALUE_TYPE VALUE_REMOVE_LAST_KEY() {
-			VALUE_TYPE result = LAST_ENTRY_VALUE();
-			POLL_LAST_ENTRY_KEY();
-			return result; 
 		}
+		
+		@Override
+		public void clear() {
+			LINKED_HASH_MAP.this.clear();
+		}
+		
 		@Override
 		public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
 			Objects.requireNonNull(action);
@@ -1359,7 +1231,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 #endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1374,19 +1246,19 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				state = operator.APPLY_VALUE(state, values[index]);
 				index = (int)links[index];
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return VALUE_OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_VALUE;
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(values[index])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[index]);
+				if(filter.test(values[index])) return values[index];
 				index = (int)links[index];
 			}
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override
@@ -1406,7 +1278,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry = new MapEntry();
 		
-		public FastEntryIterator(boolean start) { super(start); }
+		public FastEntryIterator() {}
 		public FastEntryIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1433,7 +1305,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry;
 		
-		public EntryIterator(boolean start) { super(start); }
+		public EntryIterator() {}
 		public EntryIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1463,7 +1335,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	
 	private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		
-		public KeyIterator(boolean start) { super(start); }
+		public KeyIterator() {}
 		public KeyIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1485,7 +1357,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	}
 	
 	private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
-		public ValueIterator(boolean start) { super(start); }
+		public ValueIterator() {}
 		
 		@Override
 		public VALUE_TYPE VALUE_PREVIOUS() {
@@ -1505,16 +1377,13 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	}
 	
 	private class MapIterator {
-		boolean forward;
 		int previous = -1;
 		int next = -1;
 		int current = -1;
 		int index = 0;
 		
-		MapIterator(boolean start) {
+		MapIterator() {
-			this.forward = start;
+			next = firstIndex;
-			if(start) next = firstIndex;
-			else previous = lastIndex;
 		}
 		
 		MapIterator(KEY_TYPE from) {
@@ -1545,11 +1414,11 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		}
 		
 		public boolean hasNext() {
-			return (forward ? next : previous) != -1;
+			return next != -1;
 		}
 
 		public boolean hasPrevious() {
-			return (forward ? previous : next) != -1;
+			return previous != -1;
 		}
 		
 		public int nextIndex() {
@@ -1609,30 +1478,20 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 		public int previousEntry() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) moveBackwards();
+			current = previous;
-			else moveForwards();
+			previous = (int)(links[current] >> 32);
+			next = current;
 			if(index >= 0) index--;
 			return current;
 		}
 		
 		public int nextEntry() {
 			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) moveForwards();
-			else moveBackwards();
-			if(index >= 0) index++;
-			return current;
-		}
-		
-		private void moveBackwards() {
-			current = previous;
-			previous = (int)(links[current] >> 32);
-			next = current;
-		}
-		
-		private void moveForwards() {
 			current = next;
 			next = (int)(links[current]);
 			previous = current;
+			if(index >= 0) index++;
+			return current;
 		}
 		
 		private void ensureIndexKnown() {

src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/OpenHashMap.template

@@ -5,17 +5,14 @@ import java.util.ConcurrentModificationException;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 #if !TYPE_OBJECT
@@ -40,12 +37,9 @@ import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 #endif
-#if !TYPE_OBJECT && !JDK_TYPE
+#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#if !VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#endif
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 #if !TYPE_OBJECT
@@ -79,7 +73,6 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 import speiger.src.collections.objects.collections.ObjectIterator;
@@ -1056,7 +1049,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -1073,25 +1066,25 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				}
 				state = operator.apply(state, new ValueMapEntry(i));
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return Optional.empty();
+			if(size() <= 0) return null;
 			MapEntry entry = new MapEntry();
 			if(containsNull) {
 				entry.set(nullIndex);
-				if(filter.test(entry)) return Optional.ofNullable(entry);
+				if(filter.test(entry)) return entry;
 			}
 			for(int i = nullIndex-1;i>=0;i--) {
 				if(KEY_EQUALS_NOT_NULL(keys[i])) {
 					entry.set(i);
-					if(filter.test(entry)) return Optional.ofNullable(entry);
+					if(filter.test(entry)) return entry;
 				}
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override
@@ -1293,7 +1286,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1310,18 +1303,18 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				}
 				state = operator.APPLY_KEY_VALUE(state, keys[i]);
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_KEY_VALUE;
-			if(containsNull && filter.test(keys[nullIndex])) return OPTIONAL.GET_OPTIONAL(keys[nullIndex]);
+			if(containsNull && filter.test(keys[nullIndex])) return keys[nullIndex];
 			for(int i = nullIndex-1;i>=0;i--) {
-				if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
+				if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(keys[i])) return keys[i];
 			}
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -1459,7 +1452,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		
 #endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1476,18 +1469,18 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				}
 				state = operator.APPLY_VALUE(state, values[i]);
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return VALUE_OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_VALUE;
-			if(containsNull && filter.test(values[nullIndex])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[nullIndex]);
+			if(containsNull && filter.test(values[nullIndex])) return values[nullIndex];
 			for(int i = nullIndex-1;i>=0;i--) {
-				if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(values[i])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[i]);
+				if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(values[i])) return values[i];
 			}
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override

src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template

@@ -4,17 +4,14 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 #if !TYPE_OBJECT
@@ -29,12 +26,9 @@ import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
-#if !TYPE_OBJECT && !JDK_TYPE
+#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#if !VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#endif
 #if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
@@ -65,14 +59,13 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 #endif
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
-import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
+import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
 import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
 #if !SAME_TYPE
@@ -126,7 +119,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	/** KeySet cache */
 	protected transient ORDERED_SET KEY_GENERIC_TYPE keySet;
 	/** Values cache */
-	protected transient VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE valuesC;
+	protected transient VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC;
 	
 	/** Amount of Elements stored in the HashMap */
 	protected int size;
@@ -327,10 +320,6 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	@Override
 	public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
 	@Override
-	public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	@Override
 	public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 	@Override
 	public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@@ -452,24 +441,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	public VALUE_TYPE LAST_ENTRY_VALUE() {
 		if(size == 0) throw new NoSuchElementException();
 		return values[lastIndex];
-	}
+	}	
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { throw new UnsupportedOperationException(); }
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { throw new UnsupportedOperationException(); }
 
 	@Override
 	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
@@ -484,7 +456,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	}
 	
 	@Override
-	public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
+	public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
 		if(valuesC == null) valuesC = new Values();
 		return valuesC;
 	}
@@ -637,10 +609,6 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
-		@Override
-		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -653,29 +621,24 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		public boolean moveToLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
 			return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
 			return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { throw new UnsupportedOperationException(); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { throw new UnsupportedOperationException(); }
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { throw new UnsupportedOperationException(); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
-			return new EntryIterator(true);
+			return new EntryIterator();
-		}
-		
-		@Override
-		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
-			return new EntryIterator(false);
 		}
 		
 		@Override
@@ -685,7 +648,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
-			return new FastEntryIterator(true);
+			return new FastEntryIterator();
 		}
 		
 		@Override
@@ -794,7 +757,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -809,21 +772,21 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 				state = operator.apply(state, new BasicEntryKV_BRACES(keys[index], values[index]));
 				index = (int)links[index];
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return Optional.empty();
+			if(size() <= 0) return null;
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES();
 			int index = firstIndex;
 			while(index != -1) {
 				entry.set(keys[index], values[index]);
-				if(filter.test(entry)) return Optional.ofNullable(entry);
+				if(filter.test(entry)) return entry;
 				index = (int)links[index];
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override
@@ -898,12 +861,6 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			throw new UnsupportedOperationException();
 		}
 		
-		@Override
-		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
-		@Override
-		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 
@@ -918,12 +875,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 		@Override
 		public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
-			return new KeyIterator(true);
+			return new KeyIterator();
-		}
-		
-		@Override
-		public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-			return new KeyIterator(false);
 		}
 		
 		@Override
@@ -943,20 +895,20 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		public void clear() { throw new UnsupportedOperationException(); }
 		
 		@Override
-		public KEY_TYPE GET_FIRST_KEY() {
+		public KEY_TYPE FIRST_KEY() {
 			return FIRST_ENTRY_KEY();
 		}
 		
 		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
+		public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); }
 
 		@Override
-		public KEY_TYPE GET_LAST_KEY() {
+		public KEY_TYPE LAST_KEY() {
 			return LAST_ENTRY_KEY();
 		}
 
 		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
+		public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
@@ -1054,7 +1006,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1069,19 +1021,19 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 				state = operator.APPLY_KEY_VALUE(state, keys[index]);
 				index = (int)links[index];
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_KEY_VALUE;
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
+				if(filter.test(keys[index])) return keys[index];
 				index = (int)links[index];
 			}
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -1098,42 +1050,39 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		}
 	}
 	
-	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
+	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
 #if VALUE_OBJECT
 		@Override
 		@Deprecated
-		public boolean contains(Object e) { return containsValue(e); }
+		public boolean contains(Object e) {
+			return containsValue(e);
+		}
 		
 #else
 		@Override
-		public boolean contains(VALUE_TYPE e) { return containsValue(e); }
+		public boolean contains(VALUE_TYPE e) {
+			return containsValue(e);
+		}
 		
 #endif
 		@Override
-		public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
+		public boolean add(VALUE_TYPE o) {
+			throw new UnsupportedOperationException();
+		}
+
 		@Override
-		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
+		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
+			return new ValueIterator();
+		}
+		
 		@Override
-		public int size() { return IMMUTABLE_HASH_MAP.this.size(); }
+		public int size() {
+			return IMMUTABLE_HASH_MAP.this.size();
+		}
+		
 		@Override
 		public void clear() { throw new UnsupportedOperationException(); }
-		@Override
+		
-		public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
-		private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
-			return new ValueIterator(false);
-		}
-		@Override
-		public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
-		@Override
-		public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
-		@Override
-		public VALUE_TYPE VALUE_REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
 		@Override
 		public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
 			int index = firstIndex;
@@ -1230,7 +1179,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 #endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1245,19 +1194,19 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 				state = operator.APPLY_VALUE(state, values[index]);
 				index = (int)links[index];
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return VALUE_OPTIONAL.empty();
+			if(size() <= 0) return EMPTY_VALUE;
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(values[index])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[index]);
+				if(filter.test(values[index])) return values[index];
 				index = (int)links[index];
 			}
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override
@@ -1277,7 +1226,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry = new MapEntry();
 		
-		public FastEntryIterator(boolean start) { super(start); }
+		public FastEntryIterator() {}
 		public FastEntryIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1303,7 +1252,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	
 	private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		
-		public EntryIterator(boolean start) { super(start); }
+		public EntryIterator() {}
 		public EntryIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1330,7 +1279,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	
 	private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		
-		public KeyIterator(boolean start) { super(start); }
+		public KeyIterator() {}
 		public KeyIterator(KEY_TYPE from) {
 			super(from);
 		}
@@ -1352,7 +1301,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	}
 	
 	private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
-		public ValueIterator(boolean start) { super(start); }
+		public ValueIterator() {}
 		
 		@Override
 		public VALUE_TYPE VALUE_PREVIOUS() {
@@ -1373,16 +1322,13 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	}
 	
 	private class MapIterator {
-		boolean forward;
 		int previous = -1;
 		int next = -1;
 		int current = -1;
 		int index = 0;
 		
-		MapIterator(boolean start) {
+		MapIterator() {
-			this.forward = start;
+			next = firstIndex;
-			if(start) next = firstIndex;
-			else previous = lastIndex;
 		}
 		
 		MapIterator(KEY_TYPE from) {
@@ -1413,11 +1359,11 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		}
 		
 		public boolean hasNext() {
-			return (forward ? next : previous) != -1;
+			return next != -1;
 		}
 
 		public boolean hasPrevious() {
-			return (forward ? previous : next) != -1;
+			return previous != -1;
 		}
 		
 		public int nextIndex() {
@@ -1434,30 +1380,20 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 		public int previousEntry() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) moveBackwards();
+			current = previous;
-			else moveForwards();
+			previous = (int)(links[current] >> 32);
+			next = current;
 			if(index >= 0) index--;
 			return current;
 		}
 		
 		public int nextEntry() {
 			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) moveForwards();
-			else moveBackwards();
-			if(index >= 0) index++;
-			return current;
-		}
-		
-		private void moveBackwards() {
-			current = previous;
-			previous = (int)(links[current] >> 32);
-			next = current;
-		}
-		
-		private void moveForwards() {
 			current = next;
 			next = (int)(links[current]);
 			previous = current;
+			if(index >= 0) index++;
+			return current;
 		}
 		
 		private void ensureIndexKnown() {

src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template

@@ -4,17 +4,14 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
@@ -29,12 +26,9 @@ import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
-#if !TYPE_OBJECT && !JDK_TYPE
+#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#if!VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#endif
 #if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
@@ -52,7 +46,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
-import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
+import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
 import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
 #if !SAME_TYPE
@@ -72,7 +66,6 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !VALUE_OBJECT
@@ -112,7 +105,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	/** KeySet cache */
 	protected ORDERED_SET KEY_GENERIC_TYPE keySet;
 	/** Values cache */
-	protected VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE valuesC;
+	protected VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC;
 	/** EntrySet cache */
 	protected FastOrderedSet KEY_VALUE_GENERIC_TYPE entrySet;
 	
@@ -282,27 +275,6 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		return lastValue;
 	}
 	
-	@Override
-	public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) {
-		int index = findIndex(key);
-		if(index < 0) {
-			insertIndex(0, key, value);
-			size++;
-			return getDefaultReturnValue();
-		}
-		return values[index];
-	}
-	
-	@Override
-	public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) {
-		int index = findIndex(key);
-		if(index < 0) {
-			insertIndex(size++, key, value);
-			return getDefaultReturnValue();
-		}
-		return values[index];
-	}
-	
 	@Override
 	public boolean moveToFirst(KEY_TYPE key) {
 		int index = findIndex(key);
@@ -430,34 +402,6 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		return result;
 	}
 	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[0], values[0]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[size-1], values[size-1]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[0], values[0]);
-		removeIndex(0);
-		return result;
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[size-1], values[size-1]);
-		removeIndex(size-1);
-		return result;
-	}
-	
 	@Override
 	public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) {
 		int index = findIndex(key);
@@ -517,7 +461,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	}
 
 	@Override
-	public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
+	public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
 		if(valuesC == null) valuesC = new Values();
 		return valuesC;
 	}
@@ -868,10 +812,6 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
-		@Override
-		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -888,24 +828,24 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
 			return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
 			return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() {
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 			POLL_FIRST_ENTRY_KEY();
 			return entry;
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() {
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 			POLL_LAST_ENTRY_KEY();
 			return entry;
@@ -913,12 +853,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
-			return new EntryIterator(true);
+			return new EntryIterator();
-		}
-		
-		@Override
-		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
-			return new EntryIterator(false);
 		}
 		
 		@Override
@@ -928,7 +863,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
-			return new FastEntryIterator(true);
+			return new FastEntryIterator();
 		}
 		
 		@Override
@@ -1020,7 +955,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -1032,19 +967,19 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				}
 				state = operator.apply(state, new ValueMapEntry(i));
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return Optional.empty();
+			if(size() <= 0) return null;
 			MapEntry entry = new MapEntry();
 			for(int i = 0;i<size;i++) {
 				entry.set(i);
-				if(filter.test(entry)) return Optional.ofNullable(entry);
+				if(filter.test(entry)) return entry;
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override
@@ -1130,10 +1065,6 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Override
 		public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
-		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
@@ -1142,9 +1073,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Override
 		public boolean moveToLast(KEY_TYPE o) { return ARRAY_MAP.this.moveToLast(o); }
 		@Override
-		public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { return new KeyIterator(true); }
+		public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { return new KeyIterator(); }
-		@Override
-		public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { return new KeyIterator(false); }
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return new KeyIterator(fromElement); } 
 		@Override
@@ -1152,13 +1081,13 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Override
 		public void clear() { ARRAY_MAP.this.clear(); }
 		@Override
-		public KEY_TYPE GET_FIRST_KEY() { return FIRST_ENTRY_KEY(); }
+		public KEY_TYPE FIRST_KEY() { return FIRST_ENTRY_KEY(); }
 		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); }
+		public KEY_TYPE POLL_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); }
 		@Override
-		public KEY_TYPE GET_LAST_KEY() { return LAST_ENTRY_KEY(); }
+		public KEY_TYPE LAST_KEY() { return LAST_ENTRY_KEY(); }
 		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); }
+		public KEY_TYPE POLL_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); }
 		
 		@Override
 		public KeySet copy() { throw new UnsupportedOperationException(); }
@@ -1233,7 +1162,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1245,16 +1174,16 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				}
 				state = operator.APPLY_KEY_VALUE(state, keys[i]);
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(int i = 0;i<size;i++) {
-				if(filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
+				if(filter.test(keys[i])) return keys[i];
 			}
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -1268,49 +1197,40 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		}
 	}
 	
-	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
+	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
 #if VALUE_OBJECT
 		@Override
-		public boolean contains(Object e) { return containsValue(e); }
+		public boolean contains(Object e) {
+			return containsValue(e);
+		}
 		
 #else
 		@Override
-		public boolean contains(VALUE_TYPE e) { return containsValue(e); }
+		public boolean contains(VALUE_TYPE e) {
+			return containsValue(e);
+		}
 		
 #endif
 		@Override
-		public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
+		public boolean add(VALUE_TYPE o) {
-		@Override
+			throw new UnsupportedOperationException();
-		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
-		@Override
-		public int size() { return ARRAY_MAP.this.size(); }
-		@Override
-		public void clear() { ARRAY_MAP.this.clear(); }
-		@Override
-		public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
-		private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
-			return new ValueIterator(false);
 		}
+
 		@Override
-		public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
+		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
-		@Override
+			return new ValueIterator();
-		public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
-		@Override
-		public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() {
-			VALUE_TYPE result = FIRST_ENTRY_VALUE();
-			POLL_FIRST_ENTRY_KEY();
-			return result; 
 		}
+		
 		@Override
-		public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
+		public int size() {
-		@Override
+			return ARRAY_MAP.this.size();
-		public VALUE_TYPE VALUE_REMOVE_LAST_KEY() {
-			VALUE_TYPE result = LAST_ENTRY_VALUE();
-			POLL_LAST_ENTRY_KEY();
-			return result; 
 		}
+		
+		@Override
+		public void clear() {
+			ARRAY_MAP.this.clear();
+		}
+		
 		@Override
 		public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
 			Objects.requireNonNull(action);
@@ -1374,7 +1294,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 #endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1386,16 +1306,16 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				}
 				state = operator.APPLY_VALUE(state, values[i]);
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(int i = 0;i<size;i++) {
-				if(filter.test(values[i])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[i]);
+				if(filter.test(values[i])) return values[i];
 			}
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override
@@ -1412,8 +1332,10 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry = new MapEntry();
 		
-		public FastEntryIterator(boolean start) { super(start); }
+		public FastEntryIterator() {}
-		public FastEntryIterator(KEY_TYPE element) { super(element); }
+		public FastEntryIterator(KEY_TYPE from) {
+			index = findIndex(from);
+		}
 		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
@@ -1436,8 +1358,11 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry = null;
 		
-		public EntryIterator(boolean start) { super(start); }
+		public EntryIterator() {}
-		public EntryIterator(KEY_TYPE element) { super(element); }
+		public EntryIterator(KEY_TYPE from) {
+			index = findIndex(from);
+			if(index == -1) throw new NoSuchElementException();
+		}
 		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
@@ -1464,8 +1389,11 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	}
 	
 	private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
-		public KeyIterator(boolean start) { super(start); }
+		public KeyIterator() {}
-		public KeyIterator(KEY_TYPE element) { super(element); }
+		public KeyIterator(KEY_TYPE element) {
+			index = findIndex(element);
+			if(index == -1) throw new NoSuchElementException();
+		}
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
@@ -1485,9 +1413,6 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	}
 	
 	private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
-		public ValueIterator(boolean start) { super(start); }
-		public ValueIterator(KEY_TYPE element) { super(element); }
-		
 		@Override
 		public VALUE_TYPE VALUE_PREVIOUS() {
 			return values[previousEntry()];
@@ -1506,37 +1431,23 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	}
 	
 	private class MapIterator {
-		boolean forward;
 		int index;
 		int lastReturned = -1;
-		
+
-		MapIterator(boolean start) {
-			this.forward = start;
-			this.index = start ? 0 : size;
-		}
-		
-		MapIterator(KEY_TYPE element) {
-			this.forward = true;
-			index = findIndex(element);
-			if(index == -1) throw new NoSuchElementException();
-		}
-		
 		public boolean hasNext() {
-			return forward ? index < size : index > 0;
+			return index < size;
 		}
 		
 		public boolean hasPrevious() {
-			return forward ? index > 0 : index < size;
+			return index > 0;
 		}
 		
 		public int nextIndex() {
-			if(forward) return index;
+			return index;
-			return size - index;
 		}
 		
 		public int previousIndex() {
-			if(forward) return index-1;
+			return index-1;
-			return (size - index)-1;
 		}
 		
 		public void remove() {
@@ -1549,42 +1460,26 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 		public int previousEntry() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) {
-				index--;
-				return (lastReturned = index);
-			}
-			lastReturned = index;
-			return index++;
-		}
-		
-		public int nextEntry() {
-			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) {
-				lastReturned = index;
-				return index++;
-			}
 			index--;
 			return (lastReturned = index);
 		}
 		
+		public int nextEntry() {
+			if(!hasNext()) throw new NoSuchElementException();
+			lastReturned = index;
+			return index++;
+		}
+		
 		public int skip(int amount) {
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			return forward ? moveForward(amount) : moveBackwards(amount);
-		}
-		
-		public int back(int amount) {
-			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			return forward ? moveBackwards(amount) : moveForward(amount);
-		}
-		
-		private int moveForward(int amount) {
 			int steps = Math.min(amount, size() - index);
 			index += steps;
 			if(steps > 0) lastReturned = Math.min(index-1, size()-1);
 			return steps;
 		}
 		
-		private int moveBackwards(int amount) {
+		public int back(int amount) {
+			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
 			int steps = Math.min(amount, index);
 			index -= steps;
 			if(steps > 0) lastReturned = Math.min(index, size()-1);

src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template

@@ -18,7 +18,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
-import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
+import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
 #if !VALUE_OBJECT && !SAME_TYPE
 import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER;
@@ -216,28 +216,6 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		return getDefaultReturnValue();
 	}
 	
-	@Override
-	public VALUE_TYPE putFirst(T key, VALUE_TYPE value) {
-		int index = key.ordinal();
-		if(isSet(index)) return values[index];
-		set(index);
-		values[index] = value;
-		onNodeAdded(index);
-		moveToFirstIndex(index);
-		return getDefaultReturnValue();
-	}
-	
-	@Override
-	public VALUE_TYPE putLast(T key, VALUE_TYPE value) {
-		int index = key.ordinal();
-		if(isSet(index)) return values[index];
-		set(index);
-		values[index] = value;
-		onNodeAdded(index);
-		moveToLastIndex(index);
-		return getDefaultReturnValue();
-	}
-	
 	@Override
 	public boolean moveToFirst(T key) {
 		int index = key.ordinal();
@@ -334,42 +312,6 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		return values[lastIndex];
 	}
 	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]);
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		int pos = firstIndex;
-		firstIndex = (int)links[pos];
-		if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L;
-		BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
-		size--;
-		values[result.ENTRY_KEY().ordinal()] = EMPTY_VALUE;
-		return result;
-	}
-	
-	@Override
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() {
-		if(size == 0) throw new NoSuchElementException();
-		int pos = lastIndex;
-		firstIndex = (int)links[pos];
-		if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L;
-		BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
-		size--;
-		values[result.ENTRY_KEY().ordinal()] = EMPTY_VALUE;
-		return result;
-	}
-	
 	@Override
 	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
@@ -383,9 +325,9 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	}
 	
 	@Override
-	public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
+	public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
 		if(valuesC == null) valuesC = new Values();
-		return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
+		return valuesC;
 	}
 	
 	@Override
@@ -473,10 +415,6 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
-		@Override
-		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -493,24 +431,24 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
 			return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
 			return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() {
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
 			POLL_FIRST_ENTRY_KEY();
 			return entry;
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() {
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
 			POLL_LAST_ENTRY_KEY();
 			return entry;
@@ -518,12 +456,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
-			return new EntryIterator(true);
+			return new EntryIterator();
-		}
-		
-		@Override
-		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
-			return new EntryIterator(false);
 		}
 		
 		@Override
@@ -533,7 +466,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
-			return new FastEntryIterator(true);
+			return new FastEntryIterator();
 		}
 		
 		@Override
@@ -641,10 +574,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		public boolean add(T o) {
 			throw new UnsupportedOperationException();
 		}
-		@Override
+		
-		public void addFirst(T o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(T o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(T o) { throw new UnsupportedOperationException(); }
 
@@ -663,12 +593,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		
 		@Override
 		public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
-			return new KeyIterator(true);
+			return new KeyIterator();
-		}
-		
-		@Override
-		public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-			return new KeyIterator(false);
 		}
 		
 		@Override
@@ -689,22 +614,22 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		}
 		
 		@Override
-		public T GET_FIRST_KEY() {
+		public T FIRST_KEY() {
 			return FIRST_ENTRY_KEY();
 		}
 		
 		@Override
-		public T REMOVE_FIRST_KEY() {
+		public T POLL_FIRST_KEY() {
 			return POLL_FIRST_ENTRY_KEY();
 		}
 
 		@Override
-		public T GET_LAST_KEY() {
+		public T LAST_KEY() {
 			return LAST_ENTRY_KEY();
 		}
 
 		@Override
-		public T REMOVE_LAST_KEY() {
+		public T POLL_LAST_KEY() {
 			return POLL_LAST_ENTRY_KEY();
 		}
 		
@@ -731,50 +656,41 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 #endif
 	}
 	
-	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
+	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
 #if VALUE_OBJECT
 		@Override
 		@Deprecated
-		public boolean contains(Object e) { return containsValue(e); }
+		public boolean contains(Object e) {
+			return containsValue(e);
+		}
 		
 #else
 		@Override
-		public boolean contains(VALUE_TYPE e) { return containsValue(e); }
+		public boolean contains(VALUE_TYPE e) {
+			return containsValue(e);
+		}
 		
 #endif
 		@Override
-		public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
+		public boolean add(VALUE_TYPE o) {
-		@Override
+			throw new UnsupportedOperationException();
-		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
-		@Override
-		public int size() { return LINKED_ENUM_MAP.this.size(); }
-		@Override
-		public void clear() { LINKED_ENUM_MAP.this.clear(); }
-		@Override
-		public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
-		private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
-			return new ValueIterator(false);
 		}
+
 		@Override
-		public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
+		public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
-		@Override
+			return new ValueIterator();
-		public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
-		@Override
-		public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() {
-			VALUE_TYPE result = FIRST_ENTRY_VALUE();
-			POLL_FIRST_ENTRY_KEY();
-			return result; 
 		}
+		
 		@Override
-		public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
+		public int size() {
-		@Override
+			return LINKED_ENUM_MAP.this.size();
-		public VALUE_TYPE VALUE_REMOVE_LAST_KEY() {
-			VALUE_TYPE result = LAST_ENTRY_VALUE();
-			POLL_LAST_ENTRY_KEY();
-			return result; 
 		}
+		
+		@Override
+		public void clear() {
+			LINKED_ENUM_MAP.this.clear();
+		}
+		
 #if VALUE_OBJECT
 		@Override
 		public void forEach(Consumer VALUE_SUPER_GENERIC_TYPE action) {
@@ -799,7 +715,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry = new MapEntry();
 		
-		public FastEntryIterator(boolean start) { super(start); }
+		public FastEntryIterator() {}
 		public FastEntryIterator(T from) {
 			super(from);
 		}
@@ -826,7 +742,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		MapEntry entry;
 		
-		public EntryIterator(boolean start) { super(start); }
+		public EntryIterator() {}
 		public EntryIterator(T from) {
 			super(from);
 		}
@@ -856,7 +772,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	
 	private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		
-		public KeyIterator(boolean start) { super(start); }
+		public KeyIterator() {}
 		public KeyIterator(T from) {
 			super(from);
 		}
@@ -878,7 +794,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	}
 	
 	private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
-		public ValueIterator(boolean start) { super(start); }
+		public ValueIterator() {}
 		
 		@Override
 		public VALUE_TYPE VALUE_PREVIOUS() {
@@ -899,20 +815,16 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	}
 	
 	private class MapIterator {
-		boolean forward;
 		int previous = -1;
 		int next = -1;
 		int current = -1;
 		int index = 0;
 		
-		MapIterator(boolean start) {
+		MapIterator() {
-			this.forward = start;
+			next = firstIndex;
-			if(start) next = firstIndex;
-			else previous = lastIndex;
 		}
 		
 		MapIterator(T from) {
-			this.forward = true;
 			previous = from.ordinal() - 1;
 			index = from.ordinal();
 			next = from.ordinal();
@@ -920,11 +832,11 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		}
 		
 		public boolean hasNext() {
-			return (forward ? next : previous) != -1;
+			return next != -1;
 		}
 
 		public boolean hasPrevious() {
-			return (forward ? previous : next) != -1;
+			return previous != -1;
 		}
 		
 		public int nextIndex() {
@@ -959,30 +871,20 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		
 		public int previousEntry() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) moveBackwards();
+			current = previous;
-			else moveForwards();
+			previous = (int)(links[current] >> 32);
+			next = current;
 			if(index >= 0) index--;
 			return current;
 		}
 		
 		public int nextEntry() {
 			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) moveForwards();
-			else moveBackwards();
-			if(index >= 0) index++;
-			return current;
-		}
-		
-		private void moveBackwards() {
-			current = previous;
-			previous = (int)(links[current] >> 32);
-			next = current;
-		}
-		
-		private void moveForwards() {
 			current = next;
 			next = (int)(links[current]);
 			previous = current;
+			if(index >= 0) index++;
+			return current;
 		}
 		
 		private void ensureIndexKnown() {

src/builder/resources/speiger/assets/collections/templates/maps/impl/tree/AVLTreeMap.template

@@ -6,18 +6,15 @@ import java.util.Map;
 import java.util.Comparator;
 #endif
 import java.util.Objects;
-import java.util.Optional;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 
@@ -40,12 +37,9 @@ import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 #if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
-#if !TYPE_OBJECT && !JDK_TYPE
+#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#if!VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
@@ -79,7 +73,6 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT && !VALUE_OBJECT
@@ -1330,7 +1323,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1342,15 +1335,15 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				}
 				state = operator.APPLY_KEY_VALUE(state, entry.key);
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Node KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
-				if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
+				if(filter.test(entry.key)) return entry.key;
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -2033,7 +2026,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			}
 			
 			@Override
-			public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 				Objects.requireNonNull(operator);
 				MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 				boolean empty = true;
@@ -2045,19 +2038,19 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 					}
 					state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
 				}
-				return empty ? Optional.empty() : Optional.ofNullable(state);
+				return state;
 			}
 			
 			@Override
-			public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+			public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
-				if(size() <= 0) return Optional.empty();
+				if(size() <= 0) return null;
 				BasicEntry KEY_VALUE_GENERIC_TYPE subEntry = new BasicEntryKV_BRACES();
 				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
 					subEntry.set(entry.key, entry.value);
-					if(filter.test(subEntry)) return Optional.ofNullable(subEntry);
+					if(filter.test(subEntry)) return subEntry;
 				}
-				return Optional.empty();
+				return null;
 			}
 			
 			@Override
@@ -2172,7 +2165,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			
 #endif
 			@Override
-			public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 				Objects.requireNonNull(operator);
 				VALUE_TYPE state = EMPTY_VALUE;
 				boolean empty = true;
@@ -2184,15 +2177,15 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 					}
 					state = operator.APPLY_VALUE(state, entry.value);
 				}
-				return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+				return state;
 			}
 			
 			@Override
-			public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+			public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
 				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
-					if(filter.test(entry.value)) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(entry.value);
+					if(filter.test(entry.value)) return entry.value;
-				return VALUE_OPTIONAL.empty();
+				return EMPTY_VALUE;
 			}
 			
 			@Override
@@ -2528,7 +2521,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		
 		#endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -2540,15 +2533,15 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				}
 				state = operator.APPLY_VALUE(state, entry.value);
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
-				if(filter.test(entry.value)) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(entry.value);
+				if(filter.test(entry.value)) return entry.value;
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override
@@ -2694,7 +2687,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -2706,19 +2699,19 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				}
 				state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return Optional.empty();
+			if(size() <= 0) return null;
 			BasicEntry KEY_VALUE_GENERIC_TYPE subEntry = new BasicEntryKV_BRACES();
 			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
 				subEntry.set(entry.key, entry.value);
-				if(filter.test(subEntry)) return Optional.ofNullable(subEntry);
+				if(filter.test(subEntry)) return subEntry;
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override

src/builder/resources/speiger/assets/collections/templates/maps/impl/tree/RBTreeMap.template

@@ -6,18 +6,15 @@ import java.util.Map;
 import java.util.Comparator;
 #endif
 import java.util.Objects;
-import java.util.Optional;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
-import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
-import java.util.VALUE_OPTIONAL;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
@@ -39,12 +36,9 @@ import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 #if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
-#if !TYPE_OBJECT && !JDK_TYPE
+#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#if!VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
@@ -78,7 +72,6 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
-import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT && !VALUE_OBJECT
@@ -1386,7 +1379,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1398,15 +1391,15 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				}
 				state = operator.APPLY_KEY_VALUE(state, entry.key);
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Node KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
-				if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
+				if(filter.test(entry.key)) return entry.key;
-			return OPTIONAL.empty();
+			return EMPTY_KEY_VALUE;
 		}
 		
 		@Override
@@ -2099,7 +2092,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			}
 			
 			@Override
-			public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 				Objects.requireNonNull(operator);
 				MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 				boolean empty = true;
@@ -2111,19 +2104,19 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 					}
 					state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
 				}
-				return empty ? Optional.empty() : Optional.ofNullable(state);
+				return state;
 			}
 			
 			@Override
-			public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+			public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
-				if(size() <= 0) return Optional.empty();
+				if(size() <= 0) return null;
 				BasicEntry KEY_VALUE_GENERIC_TYPE subEntry = new BasicEntryKV_BRACES();
 				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
 					subEntry.set(entry.key, entry.value);
-					if(filter.test(subEntry)) return Optional.ofNullable(subEntry);
+					if(filter.test(subEntry)) return subEntry;
 				}
-				return Optional.empty();
+				return null;
 			}
 			
 			@Override
@@ -2238,7 +2231,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			
 #endif
 			@Override
-			public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 				Objects.requireNonNull(operator);
 				VALUE_TYPE state = EMPTY_VALUE;
 				boolean empty = true;
@@ -2250,15 +2243,15 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 					}
 					state = operator.APPLY_VALUE(state, entry.value);
 				}
-				return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+				return state;
 			}
 			
 			@Override
-			public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+			public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
 				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
-					if(filter.test(entry.value)) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(entry.value);
+					if(filter.test(entry.value)) return entry.value;
-				return VALUE_OPTIONAL.empty();
+				return EMPTY_VALUE;
 			}
 			
 			@Override
@@ -2594,7 +2587,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		
 		#endif
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -2606,15 +2599,15 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				}
 				state = operator.APPLY_VALUE(state, entry.value);
 			}
-			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
+			return state;
 		}
 		
 		@Override
-		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
-				if(filter.test(entry.value)) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(entry.value);
+				if(filter.test(entry.value)) return entry.value;
-			return VALUE_OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override
@@ -2760,7 +2753,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
 			Objects.requireNonNull(operator);
 			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
 			boolean empty = true;
@@ -2772,19 +2765,19 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				}
 				state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
 			}
-			return empty ? Optional.empty() : Optional.ofNullable(state);
+			return state;
 		}
 		
 		@Override
-		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return Optional.empty();
+			if(size() <= 0) return null;
 			BasicEntry KEY_VALUE_GENERIC_TYPE subEntry = new BasicEntryKV_BRACES();
 			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
 				subEntry.set(entry.key, entry.value);
-				if(filter.test(subEntry)) return Optional.ofNullable(subEntry);
+				if(filter.test(subEntry)) return subEntry;
 			}
-			return Optional.empty();
+			return null;
 		}
 		
 		@Override

src/builder/resources/speiger/assets/collections/templates/maps/interfaces/Map.template

@@ -154,7 +154,7 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 	 * @return the last present value or default return	value.
 	 */
 	public default CLASS_VALUE_TYPE put(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry) {
-		return put(OBJ_TO_KEY(entry.getKey()), OBJ_TO_VALUE(entry.getValue()));
+		return put(entry.getKey(), entry.getValue());
 	}
 
 #endif

src/builder/resources/speiger/assets/collections/templates/maps/interfaces/OrderedMap.template

@@ -1,15 +1,8 @@
 package speiger.src.collections.PACKAGE.maps.interfaces;
 
-#if JAVA_VERSION>=21
-import java.util.Map;
-import java.util.SequencedMap;
-
-#endif
 #if MAPS_FEATURE
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 #endif
-import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
-import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 #endif
@@ -24,11 +17,7 @@ import speiger.src.collections.objects.sets.ObjectOrderedSet;
  * @Type(T)
  * @ValueType(V)
  */
-#if JAVA_VERSION>=21
-public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERIC_TYPE, SequencedMap<CLASS_TYPE, CLASS_VALUE_TYPE>
-#else
 public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERIC_TYPE
-#endif
 {
 	/**
 	 * A customized put method that allows you to insert into the first index.
@@ -48,26 +37,6 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	 */
 	public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value);
 	
-	/**
-	 * A alternative to putAndMoveToFirst.
-	 * This method simply puts an entry at the first spot of the Map but only if the entry is missing.
-	 * @param key the key that should be inserted
-	 * @param value the value that should be inserted
-	 * @return the previous present or default return value
-	 * @see java.util.Map#put(Object, Object)
-	 */
-	public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value);
-	
-	/**
-	 * A alternative to putAndMoveToLast.
-	 * This method simply puts an entry at the last spot of the Map but only if the entry is missing.
-	 * @param key the key that should be inserted
-	 * @param value the value that should be inserted
-	 * @return the previous present or default return value
-	 * @see java.util.Map#put(Object, Object)
-	 */
-	public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value);
-	
 	/**
 	 * A specific move method to move a given key/value to the first index.
 	 * @param key that should be moved to the first index
@@ -128,34 +97,13 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	 */
 	public VALUE_TYPE LAST_ENTRY_VALUE();
 	
-	@Java21
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry();
-	@Java21
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry();
-	@Java21
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry();
-	@Java21
-	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry();
 	@Override
 	public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy();
 	@Override
 	public ORDERED_SET KEY_GENERIC_TYPE keySet();
 	@Override
-	public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values();
-	@Override
 	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET();
-	@Java21
-	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE reversed() { return new ABSTRACT_MAP.REVERSED_ORDERED_MAPKV_BRACES(this); }
 	
-#if JAVA_VERSION>=21
-	@Override
-	default ORDERED_SET KEY_GENERIC_TYPE sequencedKeySet() { return keySet(); }
-	@Override
-	default VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE sequencedValues() { return values(); }
-	@Override
-	default ObjectOrderedSet<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> sequencedEntrySet() { return (ObjectOrderedSet<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>)(Object)ENTRY_SET(); }
-	
-#endif
 #if MAPS_FEATURE
 	/**
 	 * Creates a Wrapped SortedMap that is Synchronized
@@ -182,22 +130,6 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	@Override
 	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); }
 	
-#endif
-#if JAVA_VERSION>=21
-#if !SAME_TYPE || !TYPE_OBJECT
-	@Override
-	@Deprecated
-	public default CLASS_VALUE_TYPE putFirst(CLASS_TYPE k, CLASS_VALUE_TYPE v) {
-		return putFirst(OBJ_TO_KEY(k), OBJ_TO_VALUE(v));
-	}
-	
-	@Override
-	@Deprecated
-	public default CLASS_VALUE_TYPE putLast(CLASS_TYPE k, CLASS_VALUE_TYPE v) {
-		return putLast(OBJ_TO_KEY(k), OBJ_TO_VALUE(v));
-	}
-	
-#endif
 #endif
 	/**
 	 * Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value

src/builder/resources/speiger/assets/collections/templates/queues/ArrayFIFOQueue.template

@@ -7,26 +7,12 @@ import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
-#endif
 import java.util.NoSuchElementException;
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -113,47 +99,6 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 		this(MIN_CAPACITY);
 	}
 	
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a ArrayFIFOQueue
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, ARRAY_FIFO_QUEUE<T>, ARRAY_FIFO_QUEUE<T>> toQueue() {
-		return Collector.of(ARRAY_FIFO_QUEUE::new, ARRAY_FIFO_QUEUE::enqueue, ARRAY_FIFO_QUEUE::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a ArrayFIFOQueue
-	 * @Type(T)
-	 * @return a queue with the contents of the Stream
-	 */
-	public static <T> ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE toQueue(Stream<T> stream) {
-		return stream.collect(ARRAY_FIFO_QUEUE::new, ARRAY_FIFO_QUEUE::enqueue, ARRAY_FIFO_QUEUE::merge);
-	}
-	
-	private ARRAY_FIFO_QUEUE<T> merge(ARRAY_FIFO_QUEUE<T> a) {
-		enqueueAll(a.toArray((T[])new Object[a.size()]));
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a ArrayFIFOQueue
-	 * @return a queue with the contents of the Stream
-	 */
-	public static ARRAY_FIFO_QUEUE toQueue(JAVA_STREAM stream) {
-		return stream.collect(ARRAY_FIFO_QUEUE::new, ARRAY_FIFO_QUEUE::enqueue, ARRAY_FIFO_QUEUE::merge);
-	}
-	
-	private ARRAY_FIFO_QUEUE merge(ARRAY_FIFO_QUEUE a) {
-		enqueueAll(a.TO_ARRAY());
-		return this;
-	}
-	
-#endif
-#endif
 	@Override
 	public ITERATOR KEY_GENERIC_TYPE iterator() {
 		return new Iter();
@@ -373,17 +318,17 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0,m=size();i<m;i++) {
 			int index = (first + i) % array.length;
 			if(filter.test(array[index])) {
 				KEY_TYPE data = array[index];
 				removeIndex(index);
-				return OPTIONAL.GET_OPTIONAL(data);
+				return data;
 			}
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 #if !TYPE_OBJECT
@@ -410,7 +355,7 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -422,7 +367,7 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 			}
 			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override

src/builder/resources/speiger/assets/collections/templates/queues/ArrayPriorityQueue.template

@@ -8,26 +8,12 @@ import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
-#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -204,47 +190,7 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 		queue.size = size;
 		return queue;
 	}
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a ArrayPriorityQueue
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, ARRAY_PRIORITY_QUEUE<T>, ARRAY_PRIORITY_QUEUE<T>> toQueue() {
-		return Collector.of(ARRAY_PRIORITY_QUEUE::new, ARRAY_PRIORITY_QUEUE::enqueue, ARRAY_PRIORITY_QUEUE::merge);
-	}
 	
-	/**
-	 * Collects a Stream to a ArrayPriorityQueue
-	 * @Type(T)
-	 * @return a queue with the contents of the Stream
-	 */
-	public static <T> ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE toQueue(Stream<T> stream) {
-		return stream.collect(ARRAY_PRIORITY_QUEUE::new, ARRAY_PRIORITY_QUEUE::enqueue, ARRAY_PRIORITY_QUEUE::merge);
-	}
-	
-	private ARRAY_PRIORITY_QUEUE<T> merge(ARRAY_PRIORITY_QUEUE<T> a) {
-		enqueueAll(a.toArray((T[])new Object[a.size()]));
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a ArrayPriorityQueue
-	 * @return a queue with the contents of the Stream
-	 */
-	public static ARRAY_PRIORITY_QUEUE toQueue(JAVA_STREAM stream) {
-		return stream.collect(ARRAY_PRIORITY_QUEUE::new, ARRAY_PRIORITY_QUEUE::enqueue, ARRAY_PRIORITY_QUEUE::merge);
-	}
-	
-	private ARRAY_PRIORITY_QUEUE merge(ARRAY_PRIORITY_QUEUE a) {
-		enqueueAll(a.TO_ARRAY());
-		return this;
-	}
-	
-#endif
-#endif
 	@Override
 	public void enqueue(KEY_TYPE e) {
 		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (long)(array.length >> 1), (long)SanityChecks.MAX_ARRAY_SIZE), size+1));
@@ -400,7 +346,7 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -412,20 +358,20 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 			}
 			state = operator.APPLY_VALUE(state, array[i]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0;i<size;i++) {
 			if(filter.test(array[i])) {
 				KEY_TYPE data = array[i];
 				removeIndex(i);
-				return OPTIONAL.GET_OPTIONAL(data);
+				return data;
 			}
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 	@Override

src/builder/resources/speiger/assets/collections/templates/queues/HeapPriorityQueue.template

@@ -8,26 +8,12 @@ import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
-#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -207,47 +193,6 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 		return queue;
 	}
 	
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a ArrayFIFOQueue
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, HEAP_PRIORITY_QUEUE<T>, HEAP_PRIORITY_QUEUE<T>> toQueue() {
-		return Collector.of(HEAP_PRIORITY_QUEUE::new, HEAP_PRIORITY_QUEUE::enqueue, HEAP_PRIORITY_QUEUE::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a ArrayFIFOQueue
-	 * @Type(T)
-	 * @return a queue with the contents of the Stream
-	 */
-	public static <T> HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE toQueue(Stream<T> stream) {
-		return stream.collect(HEAP_PRIORITY_QUEUE::new, HEAP_PRIORITY_QUEUE::enqueue, HEAP_PRIORITY_QUEUE::merge);
-	}
-	
-	private HEAP_PRIORITY_QUEUE<T> merge(HEAP_PRIORITY_QUEUE<T> a) {
-		enqueueAll(a.toArray((T[])new Object[a.size()]));
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a ArrayFIFOQueue
-	 * @return a queue with the contents of the Stream
-	 */
-	public static HEAP_PRIORITY_QUEUE toQueue(JAVA_STREAM stream) {
-		return stream.collect(HEAP_PRIORITY_QUEUE::new, HEAP_PRIORITY_QUEUE::enqueue, HEAP_PRIORITY_QUEUE::merge);
-	}
-	
-	private HEAP_PRIORITY_QUEUE merge(HEAP_PRIORITY_QUEUE a) {
-		enqueueAll(a.TO_ARRAY());
-		return this;
-	}
-	
-#endif
-#endif
 	@Override
 	public int size() {
 		return size;
@@ -381,7 +326,7 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -393,20 +338,20 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 			}
 			state = operator.APPLY_VALUE(state, array[i]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0;i<size;i++) {
 			if(filter.test(array[i])) {
 				KEY_TYPE data = array[i];
 				removeIndex(i);
-				return OPTIONAL.GET_OPTIONAL(data);
+				return data;
 			}
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 	@Override

src/builder/resources/speiger/assets/collections/templates/sets/AVLTreeSet.template

@@ -10,15 +10,6 @@ import java.util.function.BiFunction;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
@@ -28,9 +19,6 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #if !JDK_FUNCTION
@@ -220,42 +208,6 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		while(iterator.hasNext()) add(iterator.NEXT());
 	}
 	
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a AVLTreeSet
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, AVL_TREE_SET<T>, AVL_TREE_SET<T>> toSet() {
-		return Collector.of(AVL_TREE_SET::new, AVL_TREE_SET::add, AVL_TREE_SET::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a AVLTreeSet
-	 * @Type(T)
-	 * @return a set with the contents of the Stream
-	 */
-	public static <T> AVL_TREE_SET KEY_GENERIC_TYPE toSet(Stream<T> stream) {
-		return stream.collect(AVL_TREE_SET::new, AVL_TREE_SET::add, AVL_TREE_SET::merge);
-	}
-	
-	private AVL_TREE_SET<T> merge(AVL_TREE_SET<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a AVLTreeSet
-	 * @return a set with the contents of the Stream
-	 */
-	public static AVL_TREE_SET toSet(JAVA_STREAM stream) {
-		return stream.collect(AVL_TREE_SET::new, AVL_TREE_SET::add, AVL_TREE_SET::addAll);
-	}
-	
-#endif
-#endif
 #if !TYPE_OBJECT
 	@Override
 	public void setDefaultMaxValue(KEY_TYPE value) { defaultMaxNotFound = value; }
@@ -453,12 +405,12 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
-			if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
+			if(filter.test(entry.key)) return entry.key;
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 #if !TYPE_OBJECT
@@ -485,7 +437,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -497,7 +449,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			}
 			state = operator.APPLY_VALUE(state, entry.key);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
@@ -1362,7 +1314,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1374,16 +1326,16 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 				}
 				state = operator.APPLY_VALUE(state, entry.key);
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
-				if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
+				if(filter.test(entry.key)) return entry.key;
 			}
-			return OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override

src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template

@@ -6,7 +6,6 @@ import java.util.Objects;
 import java.util.Set;
 
 import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
-import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 
 /**
@@ -48,105 +47,4 @@ public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 			return false;
 		}
 	}
-	
-#if ORDERED_SET_FEATURE
-	public static class REVERSED_ORDERED_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
-		protected ORDERED_SET KEY_GENERIC_TYPE set;
-		
-		public REVERSED_ORDERED_SET(ORDERED_SET KEY_GENERIC_TYPE set) {
-			this.set = set;
-		}
-		
-		@Override
-		public REVERSED_ORDERED_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
-		@Override
-		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
-			return set.iterator(fromElement);
-		}
-		
-		@Override
-		public BI_ITERATOR KEY_GENERIC_TYPE iterator() {
-			return set.reverseIterator();
-		}
-		
-		@Override
-		public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-			return set.iterator();
-		}
-		
-		@Override
-		public void addFirst(KEY_TYPE o) {
-			set.addLast(o);
-		}
-		
-		@Override
-		public void addLast(KEY_TYPE o) {
-			set.addFirst(o);
-		}
-		
-		@Override
-#if !TYPE_OBJECT
-		public boolean remove(KEY_TYPE o) {
-#else
-		public boolean remove(Object o) {
-#endif
-			return set.remove(o);
-		}
-		
-		@Override
-		public boolean add(KEY_TYPE o) {
-			return set.add(o);
-		}
-		
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) {
-			return set.addAndMoveToLast(o);
-		}
-		
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) {
-			return set.addAndMoveToFirst(o);
-		}
-		
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) {
-			return set.moveToLast(o);
-		}
-		
-		@Override
-		public boolean moveToLast(KEY_TYPE o) {
-			return set.moveToFirst(o);
-		}
-		
-		@Override
-		public KEY_TYPE GET_FIRST_KEY() {
-			return set.GET_LAST_KEY();
-		}
-		
-		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() {
-			return set.REMOVE_LAST_KEY();
-		}
-		
-		@Override
-		public KEY_TYPE GET_LAST_KEY() {
-			return set.GET_FIRST_KEY();
-		}
-		
-		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() {
-			return set.REMOVE_FIRST_KEY();
-		}
-		
-		@Override
-		public ORDERED_SET KEY_GENERIC_TYPE reversed() {
-			return set;
-		}
-		
-		@Override
-		public int size() {
-			return set.size();
-		}
-	}
-#endif
 }

src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template

@@ -8,15 +8,6 @@ import java.util.function.BiFunction;
 #endif
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
 import java.util.Set;
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
@@ -27,9 +18,7 @@ import java.util.function.JAVA_PREDICATE;
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#if !JDK_TYPE 
+
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #if !JDK_FUNCTION
@@ -80,7 +69,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	 * @param array the array that should be used for set.
 	 */
 	public ARRAY_SET(KEY_TYPE[] array) {
-		this(array, 0, array.length);
+		this(array, array.length);
 	}
 	
 	/**
@@ -94,18 +83,6 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		addAll(array, length);
 	}
 	
-	/**
-	 * Constructur using initial Array
-	 * @param array the array that should be used for set.
-	 * @param offset the starting offset of where the array should be copied from
-	 * @param length the amount of elements present within the array
-	 * @throws NegativeArraySizeException if the length is negative
-	 */
-	public ARRAY_SET(KEY_TYPE[] array, int offset, int length) {
-		this(length);
-		addAll(array, offset, length);
-	}
-	
 	/**
 	 * A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
 	 * @param c the elements that should be added to the set.
@@ -149,42 +126,6 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		for(ITERATOR KEY_GENERIC_TYPE iter = s.iterator();iter.hasNext();data[size++] = iter.NEXT());
 	}
 	
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a ArraySet
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, ARRAY_SET<T>, ARRAY_SET<T>> toList() {
-		return Collector.of(ARRAY_SET::new, ARRAY_SET::add, ARRAY_SET::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a ArraySet
-	 * @Type(T)
-	 * @return a set with the contents of the Stream
-	 */
-	public static <T> ARRAY_SET KEY_GENERIC_TYPE toList(Stream<T> stream) {
-		return stream.collect(ARRAY_SET::new, ARRAY_SET::add, ARRAY_SET::merge);
-	}
-	
-	private ARRAY_SET<T> merge(ARRAY_SET<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a ArraySet
-	 * @return a set with the contents of the Stream
-	 */
-	public static ARRAY_SET toList(JAVA_STREAM stream) {
-		return stream.collect(ARRAY_SET::new, ARRAY_SET::add, ARRAY_SET::addAll);
-	}
-	
-#endif
-#endif
 	@Override
 	public boolean add(KEY_TYPE o) {
 		int index = findIndex(o);
@@ -207,25 +148,6 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	}
 	
 #endif
-	@Override
-	public void addFirst(KEY_TYPE o) {
-		int index = findIndex(o);
-		if(index == -1) {
-			if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
-			System.arraycopy(data, 0, data, 1, size++);
-			data[0] = o;
-		}
-	}
-	
-	@Override
-	public void addLast(KEY_TYPE o) {
-		int index = findIndex(o);
-		if(index == -1) {
-			if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
-			data[size++] = o;
-		}
-	}
-	
 	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) {
 		int index = findIndex(o);
@@ -297,13 +219,13 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	
 #endif
 	@Override
-	public KEY_TYPE GET_FIRST_KEY() {
+	public KEY_TYPE FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		return data[0];
 	}
 	
 	@Override
-	public KEY_TYPE GET_LAST_KEY() {
+	public KEY_TYPE LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		return data[size - 1];
 	}
@@ -432,7 +354,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	
 #endif
 	@Override
-	public KEY_TYPE REMOVE_FIRST_KEY() {
+	public KEY_TYPE POLL_FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		KEY_TYPE result = data[0];
 		System.arraycopy(data, 1, data, 0, --size);
@@ -443,7 +365,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	}
 	
 	@Override
-	public KEY_TYPE REMOVE_LAST_KEY() {
+	public KEY_TYPE POLL_LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		size--;
 #if TYPE_OBJECT
@@ -516,12 +438,12 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0;i<size;i++) {
-			if(filter.test(data[i])) return OPTIONAL.GET_OPTIONAL(data[i]);
+			if(filter.test(data[i])) return data[i];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 #if !TYPE_OBJECT
@@ -548,7 +470,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -560,7 +482,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 			}
 			state = operator.APPLY_VALUE(state, data[i]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
@@ -589,18 +511,13 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	
 	@Override
 	public BI_ITERATOR KEY_GENERIC_TYPE iterator() {
-		return new SetIterator(true, 0);
+		return new SetIterator(0);
-	}
-	
-	@Override
-	public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-		return new SetIterator(false, size);
 	}
 	
 	@Override
 	public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
 		int index = findIndex(fromElement);
-		if(index != -1) return new SetIterator(true, index);
+		if(index != -1) return new SetIterator(index);
 		throw new NoSuchElementException();
 	}
 	
@@ -653,57 +570,45 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	}
 		
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
-		boolean forward;
 		int index;
 		int lastReturned = -1;
 		
-		public SetIterator(boolean forward, int index) {
+		public SetIterator(int index) {
-			this.forward = forward;
 			this.index = index;
 		}
 		
 		@Override
 		public boolean hasNext() {
-			return forward ? index < size() : index > 0;
+			return index < size();
 		}
 		
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) {
-				lastReturned = index;
-				return data[index++];				
-			}
-			index--;
-			return data[(lastReturned = index)];
-		}
-		
-		@Override
-		public boolean hasPrevious() {
-			return forward ? index > 0 : index < size();
-		}
-		
-		@Override
-		public KEY_TYPE PREVIOUS() {
-			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) {
-				index--;
-				return data[(lastReturned = index)];
-			}
 			lastReturned = index;
 			return data[index++];
 		}
 		
+		@Override
+		public boolean hasPrevious() {
+			return index > 0;
+		}
+		
+		@Override
+		public KEY_TYPE PREVIOUS() {
+			if(!hasPrevious()) throw new NoSuchElementException();
+			--index;
+			return data[(lastReturned = index)];
+		}
+		
 		@Override
 		public int nextIndex() {
-			if(forward) return index;
+			return index;
-			return size - index;
 		}
 		
 		@Override
 		public int previousIndex() {
-			if(forward) return index-1;
+			return index-1;
-			return (size - index)-1;
 		}
 		
 		@Override
@@ -732,23 +637,15 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		@Override
 		public int skip(int amount) {
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			return forward ? moveForward(amount) : moveBackwards(amount);
-		}
-		
-		@Override
-		public int back(int amount) {
-			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			return forward ? moveBackwards(amount) : moveForward(amount);
-		}
-		
-		private int moveForward(int amount) {
 			int steps = Math.min(amount, size() - index);
 			index += steps;
 			if(steps > 0) lastReturned = Math.min(index-1, size()-1);
 			return steps;
 		}
 		
-		private int moveBackwards(int amount) {
+		@Override
+		public int back(int amount) {
+			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
 			int steps = Math.min(amount, index);
 			index -= steps;
 			if(steps > 0) lastReturned = Math.min(index, size()-1);

src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template

@@ -9,9 +9,6 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
@@ -22,9 +19,6 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #if !JDK_FUNCTION
@@ -264,10 +258,6 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	@Override
 	public boolean addAll(COLLECTION KEY_GENERIC_TYPE c) { throw new UnsupportedOperationException(); }
 	@Override
-	public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	@Override
-	public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 	@Override
 	public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
@@ -295,22 +285,22 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	}
 	
 	@Override
-	public KEY_TYPE GET_FIRST_KEY() {
+	public KEY_TYPE FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		return keys[firstIndex];
 	}
 	
 	@Override
-	public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
+	public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); }
 	
 	@Override
-	public KEY_TYPE GET_LAST_KEY() {
+	public KEY_TYPE LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		return keys[lastIndex];
 	}
 	
 	@Override
-	public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
+	public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); }
 	@Override
 	public boolean remove(Object o) { throw new UnsupportedOperationException(); }
 
@@ -424,7 +414,7 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -437,18 +427,18 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 			else state = operator.APPLY_VALUE(state, keys[index]);
 			index = (int)links[index];
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		int index = firstIndex;
 		while(index != -1) {
-			if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
+			if(filter.test(keys[index])) return keys[index];
 			index = (int)links[index];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 	@Override
@@ -465,12 +455,7 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	
 	@Override
 	public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
-		return new SetIterator(true);
+		return new SetIterator();
-	}
-	
-	@Override
-	public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-		return new SetIterator(false);
 	}
 	
 	@Override
@@ -536,20 +521,16 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	}
 
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
-		boolean forward;
 		int previous = -1;
 		int next = -1;
 		int current = -1;
-		int index = -1;
+		int index = 0;
 		
-		SetIterator(boolean start) {
+		SetIterator() {
-			this.forward = start;
+			next = firstIndex;
-			if(start) next = firstIndex;
-			else previous = lastIndex;
 		}
 		
 		SetIterator(KEY_TYPE from) {
-			this.forward = true;
 			if(KEY_EQUALS_NULL(from)) {
 				if(containsNull) {
 					next = (int) links[nullIndex];
@@ -578,60 +559,48 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		
 		@Override
 		public int skip(int amount) {
-			int result = forward ? moveForward(amount) : moveBackwards(amount);
-			if(index >= 0) index+=result;
-			return result;
-		}
-		
-		@Override
-		public int back(int amount) {
-			int result = forward ? moveBackwards(amount) : moveForward(amount);
-			if(index >= 0) index-=result;
-			return result;
-		}
-		
-		private int moveForward(int amount) {
 			int result = 0;
 			while(next != -1 && result != amount) {
 				current = previous = next;
 				next = (int)(links[current]);
 				result++;
 			}
+			if(index >= 0) index+=result;
 			return result;
 		}
 		
-		private int moveBackwards(int amount) {
+		@Override
+		public int back(int amount) {
 			int result = 0;
 			while(previous != -1 && result != amount) {
 				current = next = previous;
 				previous = (int)(links[current] >> 32);
 				result++;
 			}
+			if(index >= 0) index-=result;
 			return result;
 		}
 		
 		@Override
 		public boolean hasNext() {
-			return (forward ? next : previous) != -1;
+			return next != -1;
 		}
 
 		@Override
 		public boolean hasPrevious() {
-			return (forward ? previous : next) != -1;
+			return previous != -1;
 		}
 		
 		@Override
 		public int nextIndex() {
 			ensureIndexKnown();
-			if(forward) return index;
+			return index;
-			return size - index;
 		}
 		
 		@Override
 		public int previousIndex() {
 			ensureIndexKnown();
-			if(forward) return index-1;
+			return index - 1;
-			return (size - index)-1;
 		}
 		
 		@Override
@@ -640,8 +609,8 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) moveBackwards();
+			current = next = previous;
-			else moveForwards();
+			previous = (int)(links[current] >> 32);
 			if(index >= 0) index--;
 			return keys[current];
 		}
@@ -649,20 +618,10 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) moveForwards();
-			else moveBackwards();
-			if(index >= 0) index++;
-			return keys[current];
-		}
-		
-		private void moveBackwards() {
-			current = next = previous;
-			previous = (int)(links[current] >> 32);
-		}
-		
-		private void moveForwards() {
 			current = previous = next;
 			next = (int)(links[current]);
+			if(index >= 0) index++;
+			return keys[current];
 		}
 		
 		private void ensureIndexKnown() {

src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template

@@ -9,15 +9,6 @@ import java.util.Objects;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
@@ -27,9 +18,6 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #endif
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -247,82 +235,6 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	}
 	
 #endif
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a LinkedCustomHashSet
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, LINKED_CUSTOM_HASH_SET<T>, LINKED_CUSTOM_HASH_SET<T>> toLinkedSet(STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
-		return Collector.of(() -> new LINKED_CUSTOM_HASH_SET<>(strategy), LINKED_CUSTOM_HASH_SET::add, LINKED_CUSTOM_HASH_SET::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a LinkedCustomHashSet
-	 * @Type(T)
-	 * @return a set with the contents of the Stream
-	 */
-	public static <T> LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE toLinkedSet(Stream<T> stream, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
-		return stream.collect(() -> new LINKED_CUSTOM_HASH_SET<>(strategy), LINKED_CUSTOM_HASH_SET::add, LINKED_CUSTOM_HASH_SET::merge);
-	}
-	
-	private LINKED_CUSTOM_HASH_SET<T> merge(LINKED_CUSTOM_HASH_SET<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a LinkedCustomHashSet
-	 * @return a set with the contents of the Stream
-	 */
-	public static LINKED_CUSTOM_HASH_SET toList(JAVA_STREAM stream, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
-		return stream.collect(() -> new LINKED_CUSTOM_HASH_SET(strategy), LINKED_CUSTOM_HASH_SET::add, LINKED_CUSTOM_HASH_SET::addAll);
-	}
-	
-#endif
-#endif
-	@Override
-	public void addFirst(KEY_TYPE o) {
-		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
-			if(containsNull) return;
-			containsNull = true;
-			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex);
-		}
-		else {
-			int pos = HashUtil.mix(strategy.hashCode(o)) & mask;
-			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
-				if(strategy.equals(keys[pos], o)) return;
-				pos = ++pos & mask;
-			}
-			keys[pos] = o;
-			onNodeAdded(pos);
-			moveToFirstIndex(pos);
-		}
-		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
-	}
-	
-	@Override
-	public void addLast(KEY_TYPE o) {
-		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
-			if(containsNull) return;
-			containsNull = true;
-			onNodeAdded(nullIndex);
-		}
-		else {
-			int pos = HashUtil.mix(strategy.hashCode(o)) & mask;
-			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
-				if(strategy.equals(keys[pos], o)) return;
-				pos = ++pos & mask;
-			}
-			keys[pos] = o;
-			onNodeAdded(pos);
-		}
-		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
-	}
-	
 	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) {
 		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
@@ -379,7 +291,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	
 	@Override
 	public boolean moveToFirst(KEY_TYPE o) {
-		if(isEmpty() || strategy.equals(GET_FIRST_KEY(), o)) return false;
+		if(isEmpty() || strategy.equals(FIRST_KEY(), o)) return false;
 		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
 				moveToFirstIndex(nullIndex);
@@ -401,7 +313,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	
 	@Override
 	public boolean moveToLast(KEY_TYPE o) {
-		if(isEmpty() || strategy.equals(GET_LAST_KEY(), o)) return false;
+		if(isEmpty() || strategy.equals(LAST_KEY(), o)) return false;
 		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
 				moveToLastIndex(nullIndex);
@@ -458,13 +370,13 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	}
 	
 	@Override
-	public KEY_TYPE GET_FIRST_KEY() {
+	public KEY_TYPE FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		return keys[firstIndex];
 	}
 	
 	@Override
-	public KEY_TYPE REMOVE_FIRST_KEY() {
+	public KEY_TYPE POLL_FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = firstIndex;
 		onNodeRemoved(pos);
@@ -480,13 +392,13 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	}
 	
 	@Override
-	public KEY_TYPE GET_LAST_KEY() {
+	public KEY_TYPE LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		return keys[lastIndex];
 	}
 	
 	@Override
-	public KEY_TYPE REMOVE_LAST_KEY() {
+	public KEY_TYPE POLL_LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = lastIndex;
 		onNodeRemoved(pos);
@@ -744,7 +656,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -757,18 +669,18 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 			else state = operator.APPLY_VALUE(state, keys[index]);
 			index = (int)links[index];
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		int index = firstIndex;
 		while(index != -1) {
-			if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
+			if(filter.test(keys[index])) return keys[index];
 			index = (int)links[index];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 	@Override
@@ -785,12 +697,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	
 	@Override
 	public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
-		return new SetIterator(true);
+		return new SetIterator();
-	}
-	
-	@Override
-	public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-		return new SetIterator(false);
 	}
 	
 	@Override
@@ -815,20 +722,16 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	}
 	
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
-		boolean forward;
 		int previous = -1;
 		int next = -1;
 		int current = -1;
-		int index = -1;
+		int index = 0;
 		
-		SetIterator(boolean start) {
+		SetIterator() {
-			this.forward = start;
+			next = firstIndex;
-			if(start) next = firstIndex;
-			else previous = lastIndex;
 		}
 		
 		SetIterator(KEY_TYPE from) {
-			this.forward = true;
 			if(strategy.equals(from, EMPTY_KEY_VALUE)) {
 				if(containsNull) {
 					next = (int) links[nullIndex];
@@ -857,60 +760,48 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		
 		@Override
 		public boolean hasNext() {
-			return (forward ? next : previous) != -1;
+			return next != -1;
 		}
 
 		@Override
 		public boolean hasPrevious() {
-			return (forward ? previous : next) != -1;
+			return previous != -1;
 		}
 		
 		@Override
 		public int skip(int amount) {
-			int result = forward ? moveForward(amount) : moveBackwards(amount);
-			if(index >= 0) index+=result;
-			return result;
-		}
-		
-		@Override
-		public int back(int amount) {
-			int result = forward ? moveBackwards(amount) : moveForward(amount);
-			if(index >= 0) index-=result;
-			return result;
-		}
-		
-		private int moveForward(int amount) {
 			int result = 0;
 			while(next != -1 && result != amount) {
 				current = previous = next;
 				next = (int)(links[current]);
 				result++;
 			}
+			if(index >= 0) index+=result;
 			return result;
 		}
 		
-		private int moveBackwards(int amount) {
+		@Override
+		public int back(int amount) {
 			int result = 0;
 			while(previous != -1 && result != amount) {
 				current = next = previous;
 				previous = (int)(links[current] >> 32);
 				result++;
 			}
+			if(index >= 0) index-=result;
 			return result;
 		}
 		
 		@Override
 		public int nextIndex() {
 			ensureIndexKnown();
-			if(forward) return index;
+			return index;
-			return size - index;
 		}
 		
 		@Override
 		public int previousIndex() {
 			ensureIndexKnown();
-			if(forward) return index-1;
+			return index - 1;
-			return (size - index)-1;
 		}
 		
 		@Override
@@ -959,8 +850,8 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) moveBackwards();
+			current = next = previous;
-			else moveForwards();
+			previous = (int)(links[current] >> 32);
 			if(index >= 0) index--;
 			return keys[current];
 		}
@@ -968,20 +859,10 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) moveForwards();
-			else moveBackwards();
-			if(index >= 0) index++;
-			return keys[current];
-		}
-		
-		private void moveBackwards() {
-			current = next = previous;
-			previous = (int)(links[current] >> 32);
-		}
-		
-		private void moveForwards() {
 			current = previous = next;
 			next = (int)(links[current]);
+			if(index >= 0) index++;
+			return keys[current];
 		}
 		
 		private void ensureIndexKnown() {

src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template

@@ -5,15 +5,6 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
 #if TYPE_OBJECT
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
@@ -30,9 +21,6 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #if !JDK_FUNCTION
@@ -218,82 +206,6 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	}
 	
 #endif
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a LinkedHashSet
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, LINKED_HASH_SET<T>, LINKED_HASH_SET<T>> toLinkedSet() {
-		return Collector.of(LINKED_HASH_SET::new, LINKED_HASH_SET::add, LINKED_HASH_SET::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a LinkedHashSet
-	 * @Type(T)
-	 * @return a set with the contents of the Stream
-	 */
-	public static <T> LINKED_HASH_SET KEY_GENERIC_TYPE toLinkedSet(Stream<T> stream) {
-		return stream.collect(LINKED_HASH_SET::new, LINKED_HASH_SET::add, LINKED_HASH_SET::merge);
-	}
-	
-	private LINKED_HASH_SET<T> merge(LINKED_HASH_SET<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a LinkedHashSet
-	 * @return a set with the contents of the Stream
-	 */
-	public static LINKED_HASH_SET toLinkedSet(JAVA_STREAM stream) {
-		return stream.collect(LINKED_HASH_SET::new, LINKED_HASH_SET::add, LINKED_HASH_SET::addAll);
-	}
-	
-#endif
-#endif
-	@Override
-	public void addFirst(KEY_TYPE o) {
-		if(KEY_EQUALS_NULL(o)) {
-			if(containsNull) return;
-			containsNull = true;
-			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex);
-		}
-		else {
-			int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask;
-			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
-				if(KEY_EQUALS(keys[pos], o)) return;
-				pos = ++pos & mask;
-			}
-			keys[pos] = o;
-			onNodeAdded(pos);
-			moveToFirstIndex(pos);
-		}
-		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
-	}
-	
-	@Override
-	public void addLast(KEY_TYPE o) {
-		if(KEY_EQUALS_NULL(o)) {
-			if(containsNull) return;
-			containsNull = true;
-			onNodeAdded(nullIndex);
-		}
-		else {
-			int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask;
-			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
-				if(KEY_EQUALS(keys[pos], o)) return;
-				pos = ++pos & mask;
-			}
-			keys[pos] = o;
-			onNodeAdded(pos);
-		}
-		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
-	}
-	
 	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) {
 		if(KEY_EQUALS_NULL(o)) {
@@ -350,7 +262,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	
 	@Override
 	public boolean moveToFirst(KEY_TYPE o) {
-		if(isEmpty() || KEY_EQUALS(GET_FIRST_KEY(), o)) return false;
+		if(isEmpty() || KEY_EQUALS(FIRST_KEY(), o)) return false;
 		if(KEY_EQUALS_NULL(o)) {
 			if(containsNull) {
 				moveToFirstIndex(nullIndex);
@@ -372,7 +284,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	
 	@Override
 	public boolean moveToLast(KEY_TYPE o) {
-		if(isEmpty() || KEY_EQUALS(GET_LAST_KEY(), o)) return false;
+		if(isEmpty() || KEY_EQUALS(LAST_KEY(), o)) return false;
 		if(KEY_EQUALS_NULL(o)) {
 			if(containsNull) {
 				moveToLastIndex(nullIndex);
@@ -429,13 +341,13 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	}
 	
 	@Override
-	public KEY_TYPE GET_FIRST_KEY() {
+	public KEY_TYPE FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		return keys[firstIndex];
 	}
 	
 	@Override
-	public KEY_TYPE REMOVE_FIRST_KEY() {
+	public KEY_TYPE POLL_FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = firstIndex;
 		onNodeRemoved(pos);
@@ -451,13 +363,13 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	}
 	
 	@Override
-	public KEY_TYPE GET_LAST_KEY() {
+	public KEY_TYPE LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		return keys[lastIndex];
 	}
 	
 	@Override
-	public KEY_TYPE REMOVE_LAST_KEY() {
+	public KEY_TYPE POLL_LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = lastIndex;
 		onNodeRemoved(pos);
@@ -599,7 +511,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -612,18 +524,18 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 			else state = operator.APPLY_VALUE(state, keys[index]);
 			index = (int)links[index];
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		int index = firstIndex;
 		while(index != -1) {
-			if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
+			if(filter.test(keys[index])) return keys[index];
 			index = (int)links[index];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 	@Override
@@ -756,12 +668,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	
 	@Override
 	public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
-		return new SetIterator(true);
+		return new SetIterator();
-	}
-	
-	@Override
-	public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
-		return new SetIterator(false);
 	}
 	
 	@Override
@@ -786,20 +693,16 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	}
 	
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
-		boolean forward;
 		int previous = -1;
 		int next = -1;
 		int current = -1;
-		int index = -1;
+		int index = 0;
 		
-		SetIterator(boolean start) {
+		SetIterator() {
-			this.forward = start;
+			next = firstIndex;
-			if(start) next = firstIndex;
-			else previous = lastIndex;
 		}
 		
 		SetIterator(KEY_TYPE from) {
-			this.forward = true;
 			if(KEY_EQUALS_NULL(from)) {
 				if(containsNull) {
 					next = (int) links[nullIndex];
@@ -828,60 +731,48 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		
 		@Override
 		public int skip(int amount) {
-			int result = forward ? moveForward(amount) : moveBackwards(amount);
-			if(index >= 0) index+=result;
-			return result;
-		}
-		
-		@Override
-		public int back(int amount) {
-			int result = forward ? moveBackwards(amount) : moveForward(amount);
-			if(index >= 0) index-=result;
-			return result;
-		}
-		
-		private int moveForward(int amount) {
 			int result = 0;
 			while(next != -1 && result != amount) {
 				current = previous = next;
 				next = (int)(links[current]);
 				result++;
 			}
+			if(index >= 0) index+=result;
 			return result;
 		}
 		
-		private int moveBackwards(int amount) {
+		@Override
+		public int back(int amount) {
 			int result = 0;
 			while(previous != -1 && result != amount) {
 				current = next = previous;
 				previous = (int)(links[current] >> 32);
 				result++;
 			}
+			if(index >= 0) index-=result;
 			return result;
 		}
 		
 		@Override
 		public boolean hasNext() {
-			return (forward ? next : previous) != -1;
+			return next != -1;
 		}
 
 		@Override
 		public boolean hasPrevious() {
-			return (forward ? previous : next) != -1;
+			return previous != -1;
 		}
 		
 		@Override
 		public int nextIndex() {
 			ensureIndexKnown();
-			if(forward) return index;
+			return index;
-			return size - index;
 		}
 		
 		@Override
 		public int previousIndex() {
 			ensureIndexKnown();
-			if(forward) return index-1;
+			return index - 1;
-			return (size - index)-1;
 		}
 		
 		@Override
@@ -930,8 +821,8 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			if(forward) moveBackwards();
+			current = next = previous;
-			else moveForwards();
+			previous = (int)(links[current] >> 32);
 			if(index >= 0) index--;
 			return keys[current];
 		}
@@ -939,20 +830,10 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			if(forward) moveForwards();
-			else moveBackwards();
-			if(index >= 0) index++;
-			return keys[current];
-		}
-		
-		private void moveBackwards() {
-			current = next = previous;
-			previous = (int)(links[current] >> 32);
-		}
-		
-		private void moveForwards() {
 			current = previous = next;
 			next = (int)(links[current]);
+			if(index >= 0) index++;
+			return keys[current];
 		}
 		
 		private void ensureIndexKnown() {

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/OpenCustomHashSet.template

@@ -6,15 +6,6 @@ import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
 #if TYPE_OBJECT
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
@@ -25,9 +16,6 @@ import java.util.function.PREDICATE;
 
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -263,42 +251,6 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 		while(iterator.hasNext()) add(iterator.NEXT());
 	}
 	
-#endif
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a CustomHashSet
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, CUSTOM_HASH_SET<T>, CUSTOM_HASH_SET<T>> toSet(STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
-		return Collector.of(() -> new CUSTOM_HASH_SET<>(strategy), CUSTOM_HASH_SET::add, CUSTOM_HASH_SET::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a CustomHashSet
-	 * @Type(T)
-	 * @return a set with the contents of the Stream
-	 */
-	public static <T> CUSTOM_HASH_SET KEY_GENERIC_TYPE toSet(Stream<T> stream, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
-		return stream.collect(() -> new CUSTOM_HASH_SET<>(strategy), CUSTOM_HASH_SET::add, CUSTOM_HASH_SET::merge);
-	}
-	
-	private CUSTOM_HASH_SET<T> merge(CUSTOM_HASH_SET<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a CustomHashSet
-	 * @return a set with the contents of the Stream
-	 */
-	public static CUSTOM_HASH_SET toSet(JAVA_STREAM stream, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
-		return stream.collect(() -> new CUSTOM_HASH_SET(strategy), CUSTOM_HASH_SET::add, CUSTOM_HASH_SET::addAll);
-	}
-	
-#endif
 #endif
 	/**
 	 * Helper getter function to get the current strategy
@@ -683,7 +635,7 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -700,18 +652,18 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 			}
 			state = operator.APPLY_VALUE(state, keys[i]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
-		if(size() <= 0) return OPTIONAL.empty();
+		if(size() <= 0) return EMPTY_VALUE;
-		if(containsNull && filter.test(keys[nullIndex])) return OPTIONAL.GET_OPTIONAL(keys[nullIndex]);
+		if(containsNull && filter.test(keys[nullIndex])) return keys[nullIndex];
 		for(int i = nullIndex-1;i>=0;i--) {
-			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
+			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(keys[i])) return keys[i];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 	@Override

src/builder/resources/speiger/assets/collections/templates/sets/OpenHashSet.template

@@ -6,15 +6,6 @@ import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
 #if TYPE_OBJECT
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
@@ -29,9 +20,6 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #if !JDK_FUNCTION
@@ -230,42 +218,6 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 		while(iterator.hasNext()) add(iterator.NEXT());
 	}
 	
-#endif
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a HashSet
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, HASH_SET<T>, HASH_SET<T>> toSet() {
-		return Collector.of(HASH_SET::new, HASH_SET::add, HASH_SET::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a HashSet
-	 * @Type(T)
-	 * @return a set with the contents of the Stream
-	 */
-	public static <T> HASH_SET KEY_GENERIC_TYPE toSet(Stream<T> stream) {
-		return stream.collect(HASH_SET::new, HASH_SET::add, HASH_SET::merge);
-	}
-	
-	private HASH_SET<T> merge(HASH_SET<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a HashSet
-	 * @return a set with the contents of the Stream
-	 */
-	public static HASH_SET toSet(JAVA_STREAM stream) {
-		return stream.collect(HASH_SET::new, HASH_SET::add, HASH_SET::addAll);
-	}
-	
-#endif
 #endif
 	@Override
 	public boolean add(KEY_TYPE o) {
@@ -546,7 +498,7 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -563,18 +515,18 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 			}
 			state = operator.APPLY_VALUE(state, keys[i]);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
-		if(size() <= 0) return OPTIONAL.empty();
+		if(size() <= 0) return EMPTY_VALUE;
-		if(containsNull && filter.test(keys[nullIndex])) return OPTIONAL.GET_OPTIONAL(keys[nullIndex]);
+		if(containsNull && filter.test(keys[nullIndex])) return keys[nullIndex];
 		for(int i = nullIndex-1;i>=0;i--) {
-			if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
+			if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(keys[i])) return keys[i];
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 	@Override

src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template

@@ -1,19 +1,11 @@
 package speiger.src.collections.PACKAGE.sets;
 
-#if JAVA_VERSION>=21
-import java.util.SequencedSet;
-
-#endif
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
-import speiger.src.collections.PACKAGE.collections.ORDERED_COLLECTION;
-#if SPLIT_ITERATOR_FEATURE
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
-import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
-#endif
-import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET.REVERSED_ORDERED_SET;
 #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
@@ -23,11 +15,7 @@ import speiger.src.collections.PACKAGE.utils.SETS;
  * 
  * @Type(T)
  */
-#if JAVA_VERSION>=21
+public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE
-public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDERED_COLLECTION KEY_GENERIC_TYPE, SequencedSet<CLASS_TYPE>
-#else
-public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDERED_COLLECTION KEY_GENERIC_TYPE
-#endif
 {
 	/**
 	 * A customized add method that allows you to insert into the first index.
@@ -64,7 +52,6 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDE
 	
 	@Override
 	public BI_ITERATOR KEY_GENERIC_TYPE iterator();
-	public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator();
 	
 	/**
 	 * A type Specific Iterator starting from a given key
@@ -74,7 +61,6 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDE
 	 */
 	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
@@ -82,81 +68,27 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDE
 	@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
 	 */
-	public KEY_TYPE GET_FIRST_KEY();
+	public KEY_TYPE FIRST_KEY();
 	/**
 	 * A method to get and remove the first element in the set
 	 * @return first element in the set
 	 */
-	public KEY_TYPE REMOVE_FIRST_KEY();
+	public KEY_TYPE POLL_FIRST_KEY();
 	/**
 	 * A method to get the last element in the set
 	 * @return last element in the set
 	 */
-	public KEY_TYPE GET_LAST_KEY();
+	public KEY_TYPE LAST_KEY();
 	/**
 	 * A method to get and remove the last element in the set
 	 * @return last element in the set
 	 */
-	public KEY_TYPE REMOVE_LAST_KEY();
+	public KEY_TYPE POLL_LAST_KEY();
 	
-#if JAVA_VERSION>=21 && !TYPE_OBJECT
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void addFirst(CLASS_TYPE e) { addAndMoveToFirst(OBJ_TO_KEY(e)); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void addLast(CLASS_TYPE e) { addAndMoveToLast(OBJ_TO_KEY(e)); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default CLASS_TYPE getFirst() { return GET_FIRST_KEY(); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default CLASS_TYPE getLast() { return GET_LAST_KEY(); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default CLASS_TYPE removeFirst() { return REMOVE_FIRST_KEY(); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default CLASS_TYPE removeLast() { return REMOVE_LAST_KEY(); }
-	
-#endif
-	@Java21
-	public default ORDERED_SET KEY_GENERIC_TYPE reversed() { return new REVERSED_ORDERED_SETBRACES(this); }
-
 #if SETS_FEATURE
 	/**
 	 * Creates a Wrapped OrderedSet that is Synchronized

src/builder/resources/speiger/assets/collections/templates/sets/RBTreeSet.template

@@ -2,15 +2,6 @@ package speiger.src.collections.PACKAGE.sets;
 
 import java.util.Collection;
 import java.util.Collections;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#if !TYPE_OBJECT
-import java.util.stream.JAVA_STREAM;
-#else
-import java.util.stream.Stream;
-import java.util.stream.Collector;
-#endif
-#endif
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
@@ -28,9 +19,6 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #if !JDK_FUNCTION
@@ -220,42 +208,6 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		while(iterator.hasNext()) add(iterator.NEXT());
 	}
 	
-#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-#if TYPE_OBJECT
-	/**
-	 * Creates a Collector for a RBTreeSet
-	 * @Type(T)
-	 * @return a collector
-	 */
-	public static <T> Collector<T, RB_TREE_SET<T>, RB_TREE_SET<T>> toSet() {
-		return Collector.of(RB_TREE_SET::new, RB_TREE_SET::add, RB_TREE_SET::merge);
-	}
-	
-	/**
-	 * Collects a Stream to a RBTreeSet
-	 * @Type(T)
-	 * @return a set with the contents of the Stream
-	 */
-	public static <T> RB_TREE_SET KEY_GENERIC_TYPE toSet(Stream<T> stream) {
-		return stream.collect(RB_TREE_SET::new, RB_TREE_SET::add, RB_TREE_SET::merge);
-	}
-	
-	private RB_TREE_SET<T> merge(RB_TREE_SET<T> a) {
-		addAll(a);
-		return this;
-	}
-	
-#else
-	/**
-	 * Collects a Stream to a RBTreeSet
-	 * @return a set with the contents of the Stream
-	 */
-	public static RB_TREE_SET toSet(JAVA_STREAM stream) {
-		return stream.collect(RB_TREE_SET::new, RB_TREE_SET::add, RB_TREE_SET::addAll);
-	}
-	
-#endif
-#endif
 #if !TYPE_OBJECT
 	@Override
 	public void setDefaultMaxValue(KEY_TYPE value) { defaultMaxNotFound = value; }
@@ -475,7 +427,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -487,16 +439,16 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			}
 			state = operator.APPLY_VALUE(state, entry.key);
 		}
-		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+		return state;
 	}
 	
 	@Override
-	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
-			if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
+			if(filter.test(entry.key)) return entry.key;
 		}
-		return OPTIONAL.empty();
+		return EMPTY_VALUE;
 	}
 	
 	@Override
@@ -1422,7 +1374,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1434,16 +1386,16 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 				}
 				state = operator.APPLY_VALUE(state, entry.key);
 			}
-			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
+			return state;
 		}
 		
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
-				if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
+				if(filter.test(entry.key)) return entry.key;
 			}
-			return OPTIONAL.empty();
+			return EMPTY_VALUE;
 		}
 		
 		@Override

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/Arrays.template

@@ -17,7 +17,6 @@ import java.util.function.IntFunction;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.utils.SanityChecks;
-import speiger.src.collections.utils.Swapper;
 
 /**
  * A Helper class for Arrays
@@ -338,69 +337,6 @@ public class ARRAYS
 		return array;
 	}
 	
-	/**
-	 * Simple Shuffle method for Arrays.
-	 * With a Callback for indirect shuffling
-	 * @param array the elements that should be shuffled
-	 * @param swapper the callback on the swaps
-	 * @ArrayType(T)
-	 * @note This uses the SanityChecks#getRandom
-	 * @return the provided sorted array
-	 */
-	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectShuffle(KEY_TYPE[] array, Swapper swapper) {
-		return indirectShuffle(array, SanityChecks.getRandom(), swapper);
-	}
-	
-	/**
-	 * Simple Shuffle method for Arrays.
-	 * With a Callback for indirect shuffling
-	 * @param array the elements that should be shuffled
-	 * @param random the Random Number Generator that should be used for the shuffling
-	 * @param swapper the callback on the swaps
-	 * @ArrayType(T)
-	 * @return the provided sorted array
-	 */
-	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectShuffle(KEY_TYPE[] array, RANDOM random, Swapper swapper) {
-		return indirectShuffle(array, 0, array.length, random, swapper);
-	}
-	
-	/**
-	 * Simple Shuffle method for Arrays.
-	 * With a Callback for indirect shuffling
-	 * @param array the elements that should be shuffled
-	 * @param length the length of the array
-	 * @param random the Random Number Generator that should be used for the shuffling
-	 * @param swapper the callback on the swaps
-	 * @ArrayType(T)
-	 * @return the provided sorted array
-	 */
-	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectShuffle(KEY_TYPE[] array, int length, RANDOM random, Swapper swapper) {
-		return indirectShuffle(array, 0, length, random, swapper);
-	}
-	
-	/**
-	 * Simple Shuffle method for Arrays.
-	 * With a Callback for indirect shuffling
-	 * @param array the elements that should be shuffled
-	 * @param offset the start array
-	 * @param length the length of the array
-	 * @param random the Random Number Generator that should be used for the shuffling
-	 * @param swapper the callback on the swaps
-	 * @ArrayType(T)
-	 * @return the provided sorted array
-	 */
-	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectShuffle(KEY_TYPE[] array, int offset, int length, RANDOM random, Swapper swapper) {
-		for(int i = length-1; i>=0;i--) {
-			int j = offset + i;
-			int p = offset + random.nextInt(i + 1);
-			swapper.swap(j, p);
-			KEY_TYPE t = array[j];
-			array[j] = array[p];
-			array[p] = t;
-		}
-		return array;
-	}
-	
 	/**
 	 * Simple Array Reversal method
 	 * @param array the Array that should flip
@@ -639,55 +575,6 @@ public class ARRAYS
 		}
 	}
 	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
-	 * On top of that allows to sort other things along with it.
-	 * @param array the array that needs to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 * @return input array
-	 */
-	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectInsertionSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectInsertionSort(array, 0, array.length, comp, swapper);
-		return array;
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
-	 * On top of that allows to sort other things along with it.
-	 * @param array the array that needs to be sorted
-	 * @param length the maxmium size of the array to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectInsertionSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectInsertionSort(array, 0, length, comp, swapper);
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
-	 * On top of that allows to sort other things along with it.
-	 * @param array the array that needs to be sorted
-	 * @param from where the array should be sorted from
-	 * @param to where the array should be sorted to
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectInsertionSort(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		for (int i = from+1;i<to; i++) {
-			KEY_TYPE current = array[i];
-			int j = i - 1;
-			while(j >= from && comp.compare(current, array[j]) < 0) {
-				swapper.swap(j+1, j);
-				array[j+1] = array[j--];
-			}
-			array[j+1] = current;
-		}
-	}
-	
 	/**
 	 * Sorts an array according to the natural ascending order using InsertionSort, 
 	 * @param array the array that needs to be sorted
@@ -774,60 +661,6 @@ public class ARRAYS
 		}
 	}
 	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
-	 * On top of that allows to sort other things along with it.
-	 * @param array the array that needs to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 * @return input array
-	 */
-	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectSelectionSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectSelectionSort(array, 0, array.length, comp, swapper);
-		return array;
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
-	 * On top of that allows to sort other things along with it.
-	 * @param array the array that needs to be sorted
-	 * @param length the maxmium size of the array to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectSelectionSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectSelectionSort(array, 0, length, comp, swapper);
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
-	 * On top of that allows to sort other things along with it.
-	 * @param array the array that needs to be sorted
-	 * @param from where the array should be sorted from
-	 * @param to where the array should be sorted to
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectSelectionSort(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		for (int i = from; i < to; i++) {
-			KEY_TYPE min = array[i];
-			int minId = i;
-			for(int j = i+1; j < to; j++) {
-				if(comp.compare(array[j], min) < 0) {
-					min = array[j];
-					minId = j;
-				}
-			}
-			swapper.swap(i, minId);
-			KEY_TYPE temp = array[i];
-			array[i] = min;
-			array[minId] = temp;
-		}
-	}
-	
 	/**
 	 * Sorts an array according to the natural ascending order using Selection Sort, 
 	 * @param array the array that needs to be sorted
@@ -927,72 +760,6 @@ public class ARRAYS
 		}
 	}
 	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
-	 * @param array the array that needs to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 * @return input array
-	 */
-	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectMergeSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectMergeSort(array, null, 0, array.length, comp, swapper);
-		return array;
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
-	 * @param array the array that needs to be sorted
-	 * @param length the maxmium size of the array to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectMergeSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectMergeSort(array, null, 0, length, comp, swapper);
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
-	 * @param array the array that needs to be sorted
-	 * @param supp the auxillary array that is used to simplify the sorting
-	 * @param from where the array should be sorted from
-	 * @param to where the array should be sorted to
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectMergeSort(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		if(to - from < BASE_THRESHOLD) {
-			indirectInsertionSort(array, from, to, comp, swapper);
-			return;
-		}
-		if(supp == null) supp = Arrays.copyOf(array, to);
-		int mid = (from + to) >>> 1;
-		indirectMergeSort(supp, array, from, mid, comp, swapper);
-		indirectMergeSort(supp, array, mid, to, comp, swapper);
-		if(comp.compare(supp[mid - 1], supp[mid]) <= 0)
-		{
-			System.arraycopy(supp, from, array, from, to - from);
-			return;
-		}
-		for(int p = from, q = mid;from < to;from++) {
-			if(q >= to || p < mid && comp.compare(supp[p], supp[q]) < 0) {
-				swapper.swap(from, p);
-				array[from] = supp[p++];
-				continue;
-			}
-			swapper.swap(from, q);
-			array[from] = supp[q++];
-		}
-	}
-	
 	/**
 	 * Sorts an array according to the natural ascending order using Merge Sort, 
 	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
@@ -1089,56 +856,6 @@ public class ARRAYS
 		mergeSort(array, supp, from, to, comp);
 	}
 	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using a Parallel Merge Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
-	 * @param array the array that needs to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectParallelMergeSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectParallelMergeSort(array, null, 0, array.length, comp, swapper);
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
-	 * @param array the array that needs to be sorted
-	 * @param length the maxmium size of the array to be sorted
-	 * @param swapper the callback which elements were swapped
-	 * @param comp the Comparator that decides the sorting order
-	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectParallelMergeSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectParallelMergeSort(array, null, 0, length, comp, swapper);
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
-	 * @param array the array that needs to be sorted
-	 * @param supp the auxillary array that is used to simplify the sorting
-	 * @param from where the array should be sorted from
-	 * @param to where the array should be sorted to
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectParallelMergeSort(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		if(SanityChecks.canParallelTask() && to - from >= PARALLEL_THRESHOLD) {
-			SanityChecks.invokeTask(new MergeSortActionCompSwapBRACES(array, supp, from, to, comp, swapper));
-			return;
-		}
-		indirectMergeSort(array, supp, from, to, comp, swapper);
-	}
-	
 	/**
 	 * Sorts an array according to the natural ascending order using Parallel Merge Sort, 
 	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
@@ -1492,73 +1209,6 @@ public class ARRAYS
 		if((length = d - c) > 1) quickSort(array, to - length, to, comp);
 	}
 	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
-	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
-	 * @param array the array that needs to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 * @return input array
-	 */
-	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectQuickSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectQuickSort(array, 0, array.length, comp, swapper);
-		return array;
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
-	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
-	 * @param array the array that needs to be sorted
-	 * @param length the maxmium size of the array to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectQuickSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectQuickSort(array, 0, length, comp, swapper);
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
-	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
-	 * @param array the array that needs to be sorted
-	 * @param from where the array should be sorted from
-	 * @param to where the array should be sorted to
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 */
-	public static GENERIC_KEY_BRACES void indirectQuickSort(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		int length = to - from;
-		if(length <= 0) return;
-		if(length < BASE_THRESHOLD) {
-			indirectSelectionSort(array, from, to, comp, swapper);
-			return;			
-		}
-		KEY_TYPE pivot = array[length > 128 ? subMedium(array, from, from + (length / 2), to - 1, length / 8, comp) : medium(array, from, from + (length / 2), to - 1, comp)];
-		int a = from, b = a, c = to - 1, d = c;
-		for(int compare;;swap(array, b++, c--, swapper)) {
-			for(;b<=c && (compare = comp.compare(array[b], pivot)) <= 0;b++) {
-				if(compare == 0) swap(array, a++, b, swapper);
-			}
-			for(;c>=b && (compare = comp.compare(array[c], pivot)) >= 0;c--) {
-				if(compare == 0) swap(array, c, d--, swapper);
-			}
-			if(b>c) break;
-		}
-		swap(array, from, b, Math.min(a - from, b - a), swapper); 
-		swap(array, b, to, Math.min(d - c, to - d - 1), swapper);
-		if((length = b - a) > 1) indirectQuickSort(array, from, from + length, comp, swapper);
-		if((length = d - c) > 1) indirectQuickSort(array, to - length, to, comp, swapper);
-	}
-	
 	/**
 	 * Sorts an array according to the natural ascending order using Quick Sort, 
 	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
@@ -1663,58 +1313,6 @@ public class ARRAYS
 		quickSort(array, from, to, comp);
 	}
 	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
-	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
-	 * @param array the array that needs to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
-	 */
-	public static GENERIC_KEY_BRACES void indirectParallelQuickSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectParallelQuickSort(array, 0, array.length, comp, swapper);
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
-	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
-	 * @param array the array that needs to be sorted
-	 * @param length the maxmium size of the array to be sorted
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
-	 */
-	public static GENERIC_KEY_BRACES void indirectParallelQuickSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		indirectParallelQuickSort(array, 0, length, comp, swapper);
-	}
-	
-	/**
-	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort,
-	 * On top of that allows to sort other things along with it.
-	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
-	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
-	 * @param array the array that needs to be sorted
-	 * @param from where the array should be sorted from
-	 * @param to where the array should be sorted to
-	 * @param comp the Comparator that decides the sorting order
-	 * @param swapper the callback which elements were swapped
-	 * @ArrayType(T)
-	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
-	 */
-	public static GENERIC_KEY_BRACES void indirectParallelQuickSort(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-		if(SanityChecks.canParallelTask() && to - from >= PARALLEL_THRESHOLD) {
-			SanityChecks.invokeTask(new QuickSortActionCompSwapBRACES(array, from, to, comp, swapper));
-			return;
-		}
-		indirectQuickSort(array, from, to, comp, swapper);
-	}
-	
 	/**
 	 * Sorts an array according to the natural ascending order using Parallel Quick Sort, 
 	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
@@ -1769,18 +1367,6 @@ public class ARRAYS
 		for(int i = 0;i<length;i++,swap(a, from++, to++));
 	}
 	
-	static GENERIC_KEY_BRACES void swap(KEY_TYPE[] a, int from, int to, Swapper swapper) {
-		swapper.swap(from, to);
-		KEY_TYPE t = a[from];
-		a[from] = a[to];
-		a[to] = t;
-	}
-	
-	static GENERIC_KEY_BRACES void swap(KEY_TYPE[] a, int from, int to, int length, Swapper swapper) {
-		to -= length;
-		for(int i = 0;i<length;i++,swap(a, from++, to++, swapper));
-	}
-	
 	static GENERIC_KEY_BRACES int subMedium(KEY_TYPE[] data, int a, int b, int c, int length, COMPARATOR KEY_GENERIC_TYPE comp) {
 		return medium(data, medium(data, a, a + length, a + (length * 2), comp), medium(data, b - length, b, b + length, comp), medium(data, c - (length * 2), c - length, c, comp), comp);
 	}
@@ -1803,14 +1389,16 @@ public class ARRAYS
 		int from;
 		int to;
 		
-		QuickSortAction(KEY_TYPE[] array, int from, int to) {
+		QuickSortAction(KEY_TYPE[] array, int from, int to)
+		{
 			this.array = array;
 			this.from = from;
 			this.to = to;
 		}
 		
 		@Override
-		protected void compute() {
+		protected void compute()
+		{
 			int length = to - from;
 			if(length <= 0) return;
 			if(length < BASE_THRESHOLD) {
@@ -1843,7 +1431,8 @@ public class ARRAYS
 		int to;
 		COMPARATOR KEY_GENERIC_TYPE comp;
 		
-		QuickSortActionComp(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp) {
+		QuickSortActionComp(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp)
+		{
 			this.array = array;
 			this.from = from;
 			this.to = to;
@@ -1851,7 +1440,8 @@ public class ARRAYS
 		}
 		
 		@Override
-		protected void compute() {
+		protected void compute()
+		{
 			int length = to - from;
 			if(length <= 0) return;
 			if(length < BASE_THRESHOLD) {
@@ -1877,49 +1467,6 @@ public class ARRAYS
 		}
 	}
 	
-	static class QuickSortActionCompSwap KEY_GENERIC_TYPE extends RecursiveAction {
-		private static final long serialVersionUID = 0L;
-		KEY_TYPE[] array;
-		int from;
-		int to;
-		COMPARATOR KEY_GENERIC_TYPE comp;
-		Swapper swapper;
-		
-		QuickSortActionCompSwap(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-			this.array = array;
-			this.from = from;
-			this.to = to;
-			this.comp = comp;
-			this.swapper = swapper;
-		}
-		
-		@Override
-		protected void compute() {
-			int length = to - from;
-			if(length <= 0) return;
-			if(length < BASE_THRESHOLD) {
-				indirectSelectionSort(array, from, to, comp, swapper);
-				return;			
-			}
-			KEY_TYPE pivot = array[length > 128 ? subMedium(array, from, from + (length / 2), to - 1, length / 8, comp) : medium(array, from, from + (length / 2), to - 1, comp)];
-			int a = from, b = a, c = to - 1, d = c;
-			for(int compare;;swap(array, b++, c--, swapper)) {
-				for(;b<=c && (compare = comp.compare(array[b], pivot)) <= 0;b++) {
-					if(compare == 0) swap(array, a++, b, swapper);
-				}
-				for(;c>=b && (compare = comp.compare(array[c], pivot)) >= 0;c--) {
-					if(compare == 0) swap(array, c, d--, swapper);
-				}
-				if(b>c) break;
-			}
-			swap(array, from, b, Math.min(a - from, b - a), swapper); 
-			swap(array, b, to, Math.min(d - c, to - d - 1), swapper);
-			if(b - a > 1 && d - c > 1) invokeAll(new QuickSortActionCompSwapBRACES(array, from, from + (b - a), comp, swapper), new QuickSortActionCompSwapBRACES(array, to - (d - c), to, comp, swapper));
-			else if(b - a > 1) new QuickSortActionCompSwapBRACES(array, from, from + (b - a), comp, swapper).invoke();
-			else if(d - c > 1) new QuickSortActionCompSwapBRACES(array, to - (d - c), to, comp, swapper).invoke();
-		}
-	}
-	
 	static class MergeSortAction KEY_GENERIC_TYPE extends RecursiveAction {
 		private static final long serialVersionUID = 0L;
 		KEY_TYPE[] array;
@@ -1927,7 +1474,8 @@ public class ARRAYS
 		int from;
 		int to;
 		
-		MergeSortAction(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to) {
+		MergeSortAction(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to)
+		{
 			this.array = array;
 			this.supp = supp;
 			this.from = from;
@@ -1935,7 +1483,8 @@ public class ARRAYS
 		}
 		
 		@Override
-		protected void compute() {
+		protected void compute()
+		{
 			if(to - from < BASE_THRESHOLD) {
 				insertionSort(array, from, to);
 				return;
@@ -1963,7 +1512,8 @@ public class ARRAYS
 		int to;
 		COMPARATOR KEY_GENERIC_TYPE comp;
 		
-		MergeSortActionComp(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp) {
+		MergeSortActionComp(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp)
+		{
 			this.array = array;
 			this.supp = supp;
 			this.from = from;
@@ -1972,7 +1522,8 @@ public class ARRAYS
 		}
 		
 		@Override
-		protected void compute() {
+		protected void compute()
+		{
 			if(to - from < BASE_THRESHOLD) {
 				insertionSort(array, from, to, comp);
 				return;
@@ -1992,64 +1543,22 @@ public class ARRAYS
 		}
 	}
 	
-	static class MergeSortActionCompSwap KEY_GENERIC_TYPE extends RecursiveAction {
-		private static final long serialVersionUID = 0L;
-		KEY_TYPE[] array;
-		KEY_TYPE[] supp;
-		int from;
-		int to;
-		COMPARATOR KEY_GENERIC_TYPE comp;
-		Swapper swapper;
-		
-		MergeSortActionCompSwap(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
-			this.array = array;
-			this.supp = supp;
-			this.from = from;
-			this.to = to;
-			this.comp = comp;
-			this.swapper = swapper;
-		}
-		
-		@Override
-		protected void compute() {
-			if(to - from < BASE_THRESHOLD) {
-				indirectInsertionSort(array, from, to, comp, swapper);
-				return;
-			}
-			if(supp == null) supp = Arrays.copyOf(array, to);
-			int mid = (from + to) >>> 1;
-			invokeAll(new MergeSortActionCompSwapBRACES(supp, array, from, mid, comp, swapper), new MergeSortActionCompSwapBRACES(supp, array, mid, to, comp, swapper));
-			if(comp.compare(supp[mid - 1], supp[mid]) <= 0)
-			{
-				System.arraycopy(supp, from, array, from, to - from);
-				return;
-			}
-			for(int p = from, q = mid;from < to;from++) {
-				if(q >= to || p < mid && comp.compare(supp[p], supp[q]) < 0) {
-					swapper.swap(from, p);
-					array[from] = supp[p++];
-					continue;
-				}
-				swapper.swap(from, q);
-				array[from] = supp[q++];
-			}
-		}
-	}
-	
 	static class MemFreeMergeSortAction KEY_GENERIC_TYPE extends RecursiveAction {
 		private static final long serialVersionUID = 0L;
 		KEY_TYPE[] array;
 		int from;
 		int to;
 		
-		MemFreeMergeSortAction(KEY_TYPE[] array, int from, int to) {
+		MemFreeMergeSortAction(KEY_TYPE[] array, int from, int to)
+		{
 			this.array = array;
 			this.from = from;
 			this.to = to;
 		}
 		
 		@Override
-		protected void compute() {
+		protected void compute()
+		{
 			if(to - from < BASE_THRESHOLD) {
 				insertionSort(array, from, to);
 				return;
@@ -2095,7 +1604,8 @@ public class ARRAYS
 		int to;
 		COMPARATOR KEY_GENERIC_TYPE comp;
 		
-		MemFreeMergeSortActionComp(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp) {
+		MemFreeMergeSortActionComp(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp)
+		{
 			this.array = array;
 			this.from = from;
 			this.to = to;
@@ -2103,7 +1613,8 @@ public class ARRAYS
 		}
 		
 		@Override
-		protected void compute() {
+		protected void compute()
+		{
 			if(to - from < BASE_THRESHOLD) {
 				insertionSort(array, from, to, comp);
 				return;

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

@@ -7,11 +7,6 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.locks.LockSupport;
 import java.util.function.Consumer;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#else
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if !TYPE_OBJECT
 
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -304,8 +299,9 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	 * @param operator that reduces the elements.
 	 * @return self with the reduce action applied
 	 */
-	public ObjectAsyncBuilder<OPTIONAL KEY_GENERIC_TYPE> reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public ASYNC_BUILDER KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-		return new ObjectAsyncBuilder<>(new SimpleReduceTaskBRACES(iterable.iterator(), operator));
+		task = new SimpleReduceTaskBRACES(iterable.iterator(), operator);
+		return this;
 	}
 	
 #if TYPE_OBJECT
@@ -439,8 +435,9 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	 * @param filter that decides the desired elements
 	 * @return self with the findFirst function applied
 	 */
-	public ObjectAsyncBuilder<OPTIONAL KEY_GENERIC_TYPE> findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public ASYNC_BUILDER KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
-		return new ObjectAsyncBuilder<>(new FindFirstTaskBRACES(iterable.iterator(), filter));
+		task = new FindFirstTaskBRACES(iterable.iterator(), filter);
+		return this;
 	}
 	
 #if INT_ASYNC_MODULE
@@ -593,7 +590,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	}
 	
 #endif
-	private static class SimpleReduceTask KEY_GENERIC_TYPE extends BaseObjectTask<OPTIONAL KEY_GENERIC_TYPE>
+	private static class SimpleReduceTask KEY_GENERIC_TYPE extends BASE_TASK KEY_GENERIC_TYPE
 	{
 		ITERATOR KEY_GENERIC_TYPE iter;
 		UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator;
@@ -603,7 +600,6 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		public SimpleReduceTask(ITERATOR KEY_GENERIC_TYPE iter, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			this.iter = iter;
 			this.operator = operator;
-			this.setResult(OPTIONAL.empty());
 		}
 		
 		@Override
@@ -618,7 +614,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 				}
 			}
 			if(!iter.hasNext()) {
-				setResult(OPTIONAL.GET_OPTIONAL(value));
+				setResult(value);
 				return true;
 			}
 			return false;
@@ -693,7 +689,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	}
 	
 #endif
-	private static class FindFirstTask KEY_GENERIC_TYPE extends BaseObjectTask<OPTIONAL KEY_GENERIC_TYPE>
+	private static class FindFirstTask KEY_GENERIC_TYPE extends BASE_TASK KEY_GENERIC_TYPE
 	{
 		ITERATOR KEY_GENERIC_TYPE iter;
 		PREDICATE KEY_GENERIC_TYPE filter;
@@ -701,7 +697,6 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		public FindFirstTask(ITERATOR KEY_GENERIC_TYPE iter, PREDICATE KEY_GENERIC_TYPE filter) {
 			this.iter = iter;
 			this.filter = filter;
-			this.setResult(OPTIONAL.empty());
 		}
 
 		@Override
@@ -709,7 +704,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 			while(shouldRun() && iter.hasNext()) {
 				KEY_TYPE entry = iter.NEXT();
 				if(filter.test(iter.NEXT())) {
-					setResult(OPTIONAL.GET_OPTIONAL(entry));
+					setResult(entry);
 					return true;
 				}
 			}

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

@@ -8,9 +8,6 @@ import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#endif
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.BiFunction;
@@ -26,16 +23,10 @@ import java.util.function.Consumer;
 
 import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
-#if ORDERED_MAP_FEATURE
-import speiger.src.collections.PACKAGE.collections.ORDERED_COLLECTION;
-#endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.utils.ObjectArrays;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -85,37 +76,6 @@ public class COLLECTIONS
 		return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollectionBRACES(c);
 	}
 	
-	/**
-	 * Returns a Immutable Ordered Collection instance based on the instance given.
-	 * @param c that should be made immutable/unmodifiable
-	 * @Type(T)
-	 * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself.
-	 */
-	public static GENERIC_KEY_BRACES ORDERED_COLLECTION KEY_GENERIC_TYPE unmodifiable(ORDERED_COLLECTION KEY_GENERIC_TYPE c) {
-		return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollectionBRACES(c);
-	}
-	
-	/**
-	 * Returns a synchronized ordered Collection instance based on the instance given.
-	 * @param c that should be synchronized
-	 * @Type(T)
-	 * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself.
-	 */
-	public static GENERIC_KEY_BRACES ORDERED_COLLECTION KEY_GENERIC_TYPE synchronize(ORDERED_COLLECTION KEY_GENERIC_TYPE c) {
-		return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollectionBRACES(c);
-	}
-	
-	/**
-	 * Returns a synchronized ordered Collection instance based on the instance given.
-	 * @param c that should be synchronized
-	 * @param mutex is the controller of the synchronization block.
-	 * @Type(T)
-	 * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself.
-	 */
-	public static GENERIC_KEY_BRACES ORDERED_COLLECTION KEY_GENERIC_TYPE synchronize(ORDERED_COLLECTION KEY_GENERIC_TYPE c, Object mutex) {
-		return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollectionBRACES(c, mutex);
-	}
-	
 	/**
 	 * Returns a synchronized Collection instance based on the instance given.
 	 * @param c that should be synchronized
@@ -147,10 +107,7 @@ public class COLLECTIONS
 		return new SingletonCollectionBRACES(element);
 	}
 	
-	/**
+	protected static GENERIC_KEY_BRACES CollectionWrapper KEY_GENERIC_TYPE wrapper() {
-	 * Internal Use mainly. Its a collection wrapper with 0 dependencies for those actions where a collector is needed.
-	 */
-	public static GENERIC_KEY_BRACES CollectionWrapper KEY_GENERIC_TYPE wrapper() {
 		return new CollectionWrapperBRACES();
 	}
 	
@@ -711,38 +668,6 @@ public class COLLECTIONS
 		@Override
 		public SingletonCollection KEY_GENERIC_TYPE copy() { return new SingletonCollectionBRACES(element); }
 	}
-	/**
-	 * Synchronized Ordered Collection Wrapper for the synchronizedCollection function
-	 * @Type(T)
-	 */
-	public static class SynchronizedOrderedCollection KEY_GENERIC_TYPE extends SynchronizedCollection KEY_GENERIC_TYPE implements ORDERED_COLLECTION KEY_GENERIC_TYPE {
-		ORDERED_COLLECTION KEY_GENERIC_TYPE c;
-		
-		SynchronizedOrderedCollection(ORDERED_COLLECTION KEY_GENERIC_TYPE c, Object mutex) {
-			super(c, mutex);
-			this.c = c;
-		}
-		
-		SynchronizedOrderedCollection(ORDERED_COLLECTION KEY_GENERIC_TYPE c) {
-			super(c);
-			this.c = c;
-		}
-		
-		@Override
-		public ORDERED_COLLECTION KEY_GENERIC_TYPE reversed() { return COLLECTIONS.synchronize(c.reversed(), mutex); }
-		@Override
-		public void addFirst(KEY_TYPE e) { synchronized(mutex) { this.c.addFirst(e); } }
-		@Override
-		public void addLast(KEY_TYPE e) { synchronized(mutex) { this.c.addLast(e); } }
-		@Override
-		public KEY_TYPE GET_FIRST_KEY() { synchronized(mutex) { return this.c.GET_FIRST_KEY(); } }
-		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() { synchronized(mutex) { return this.c.REMOVE_FIRST_KEY(); } }
-		@Override
-		public KEY_TYPE GET_LAST_KEY() { synchronized(mutex) { return this.c.GET_LAST_KEY(); } }
-		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() { synchronized(mutex) { return this.c.REMOVE_LAST_KEY(); } }
-	}	
 	
 	/**
 	 * Synchronized Collection Wrapper for the synchronizedCollection function
@@ -878,41 +803,13 @@ public class COLLECTIONS
 		public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return c.reduce(identity, operator); } }
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return c.reduce(operator); } }
+		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return c.reduce(operator); } }
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.findFirst(filter); } }
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.findFirst(filter); } }
 		@Override
 		public int count(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.count(filter); } }
 	}
 	
-	/**
-	 * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method
-	 * @Type(T)
-	 */
-	public static class UnmodifiableOrderedCollection KEY_GENERIC_TYPE extends UnmodifiableCollection KEY_GENERIC_TYPE implements ORDERED_COLLECTION KEY_GENERIC_TYPE {
-		ORDERED_COLLECTION KEY_GENERIC_TYPE c;
-		
-		UnmodifiableOrderedCollection(ORDERED_COLLECTION KEY_GENERIC_TYPE c) {
-			super(c);
-			this.c = c;
-		}
-		
-		@Override
-		public ORDERED_COLLECTION KEY_GENERIC_TYPE reversed() { return COLLECTIONS.unmodifiable(c.reversed()); }
-		@Override
-		public void addFirst(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public KEY_TYPE GET_FIRST_KEY() { return c.GET_FIRST_KEY(); }
-		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
-		@Override
-		public KEY_TYPE GET_LAST_KEY() { return c.GET_LAST_KEY(); }
-		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
-	}
-	
 	/**
 	 * Unmodifyable Collection Wrapper for the unmodifyableCollection method
 	 * @Type(T)
@@ -1030,9 +927,9 @@ public class COLLECTIONS
 		public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { return c.reduce(identity, operator); }
 #endif
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { return c.reduce(operator); }
+		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { return c.reduce(operator); }
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { return c.findFirst(filter); }
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { return c.findFirst(filter); }
 		@Override
 		public int count(PREDICATE KEY_GENERIC_TYPE filter) { return c.count(filter); }
 	}

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
@@ -65,7 +65,7 @@ public class ITERATORS
 	 * @Type(T)
 	 * @return an empty iterator
 	 */
-	public static GENERIC_KEY_BRACES LIST_ITERATOR KEY_GENERIC_TYPE empty() {
+	public static GENERIC_KEY_BRACES EmptyIterator KEY_GENERIC_TYPE empty() {
 #if TYPE_OBJECT
 		return (EmptyIterator<KEY_TYPE>)EMPTY;
 #else
@@ -400,7 +400,7 @@ public class ITERATORS
 	 * @ArrayType(T)
 	 * @return a Iterator that is wrapping a array.
 	 */
-	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE wrap(KEY_TYPE... a) {
+	public static GENERIC_KEY_BRACES ArrayIterator KEY_GENERIC_TYPE wrap(KEY_TYPE... a) {
 		return wrap(a, 0, a.length);
 	}
 	
@@ -412,7 +412,7 @@ public class ITERATORS
 	 * @ArrayType(T)
 	 * @return a Iterator that is wrapping a array.
 	 */
-	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE wrap(KEY_TYPE[] a, int start, int end) {
+	public static GENERIC_KEY_BRACES ArrayIterator KEY_GENERIC_TYPE wrap(KEY_TYPE[] a, int start, int end) {
 		return new ArrayIteratorBRACES(a, start, end);
 	}
 	

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

@@ -45,7 +45,7 @@ public class LISTS
 	 * @Type(T)
 	 * @return an empty list
 	 */
-	public static GENERIC_KEY_BRACES LIST KEY_GENERIC_TYPE empty() {
+	public static GENERIC_KEY_BRACES EmptyList KEY_GENERIC_TYPE empty() {
 #if TYPE_OBJECT
 		return (EmptyList<KEY_TYPE>)EMPTY;
 #else

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

@@ -4,22 +4,16 @@ package speiger.src.collections.PACKAGE.utils;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.function.Consumer;
-import java.util.function.BiFunction;
 #endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
-#if JDK_TYPE
+
-import java.util.OPTIONAL;
-#endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
-#if !JDK_TYPE 
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
 #if DEQUEUE_FEATURE
 import speiger.src.collections.PACKAGE.queues.PRIORITY_DEQUEUE;
 #endif
@@ -30,7 +24,6 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 
 /**
@@ -147,15 +140,7 @@ public class PRIORITY_QUEUES
 		@Override
 		public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return queue.matchesAll(filter); } }
 		@Override
-		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return queue.findFirst(filter); } }
+		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return queue.findFirst(filter); } }
-		#if TYPE_OBJECT
-		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) { synchronized(mutex) { return queue.reduce(identity, operator); } }
-#else
-		@Override
-		public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return queue.reduce(identity, operator); } }
-#endif
-		@Override
-		public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return queue.reduce(operator); } }
 		@Override
 		public int count(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return queue.count(filter); } }
 	}

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

@@ -360,10 +360,6 @@ public class SETS
 			s = c;
 		}
 		
-		@Override
-		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -375,19 +371,17 @@ public class SETS
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(s.iterator()); }
 		@Override
-		public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() { return ITERATORS.unmodifiable(s.reverseIterator()); }
-		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return ITERATORS.unmodifiable(s.iterator(fromElement)); }
 		@Override
 		public ORDERED_SET KEY_GENERIC_TYPE copy() { return s.copy(); }
 		@Override
-		public KEY_TYPE GET_FIRST_KEY() { return s.GET_FIRST_KEY(); }
+		public KEY_TYPE FIRST_KEY() { return s.FIRST_KEY(); }
 		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
+		public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); }
 		@Override
-		public KEY_TYPE GET_LAST_KEY() { return s.GET_LAST_KEY(); }
+		public KEY_TYPE LAST_KEY() { return s.LAST_KEY(); }
 		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
+		public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); }
 	}
 	
 #endif
@@ -654,11 +648,7 @@ public class SETS
 			super(c, mutex);
 			s = c;
 		}
-		
+
-		@Override
-		public void addFirst(KEY_TYPE o) { synchronized(mutex) { s.addFirst(o); } }
-		@Override
-		public void addLast(KEY_TYPE o) { synchronized(mutex) { s.addLast(o); } }
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToFirst(o); } }
 		@Override
@@ -670,19 +660,17 @@ public class SETS
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator() { synchronized(mutex) { return s.iterator(); } }
 		@Override
-		public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } }
-		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { synchronized(mutex) { return s.iterator(fromElement); } }
 		@Override
 		public ORDERED_SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } }
 		@Override
-		public KEY_TYPE GET_FIRST_KEY() { synchronized(mutex) { return s.GET_FIRST_KEY(); } }
+		public KEY_TYPE FIRST_KEY() { synchronized(mutex) { return s.FIRST_KEY(); } }
 		@Override
-		public KEY_TYPE REMOVE_FIRST_KEY() { synchronized(mutex) { return s.REMOVE_FIRST_KEY(); } }
+		public KEY_TYPE POLL_FIRST_KEY() { synchronized(mutex) { return s.POLL_FIRST_KEY(); } }
 		@Override
-		public KEY_TYPE GET_LAST_KEY() { synchronized(mutex) { return s.GET_LAST_KEY(); } }
+		public KEY_TYPE LAST_KEY() { synchronized(mutex) { return s.LAST_KEY(); } }
 		@Override
-		public KEY_TYPE REMOVE_LAST_KEY() { synchronized(mutex) { return s.REMOVE_LAST_KEY(); } }
+		public KEY_TYPE POLL_LAST_KEY() { synchronized(mutex) { return s.POLL_LAST_KEY(); } }
 	}
 	
 #endif

src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template

@@ -56,9 +56,6 @@ import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.PACKAGE.utils.SETS;
 #endif
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
-#if ORDERED_MAP_FEATURE
-import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
-#endif
 #if !SAME_TYPE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
 #endif
@@ -556,10 +553,6 @@ public class MAPS
 		@Override
 		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
 		@Override
-		public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
 		public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@@ -580,25 +573,13 @@ public class MAPS
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { return map.firstEntry(); }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { return map.lastEntry(); }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { throw new UnsupportedOperationException(); }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { throw new UnsupportedOperationException(); }
-		@Override
 		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { return map.copy(); }
 		@Override
 		public ORDERED_SET KEY_GENERIC_TYPE keySet() { 
 			if(keys == null) keys = SETS.unmodifiable(map.keySet()); 
 			return (ORDERED_SET KEY_GENERIC_TYPE)keys;
 		}
-		@Override
+				
-		public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
-			if(values == null) values = VALUE_COLLECTIONS.unmodifiable(map.values());
-			return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)values;
-		}
 		@Override
 		public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 			if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySetKV_BRACES(map.ENTRY_SET());
@@ -754,11 +735,7 @@ public class MAPS
 			super(c);
 			set = c;
 		}
-		
+
-		@Override
-		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -772,17 +749,15 @@ public class MAPS
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { return ObjectIterators.unmodifiable(set.iterator()); }
 		@Override
-		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); }
-		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() { return set.getFirst(); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { return set.first(); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { throw new UnsupportedOperationException(); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { throw new UnsupportedOperationException(); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() { return set.getLast(); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { return set.last(); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { throw new UnsupportedOperationException(); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { throw new UnsupportedOperationException(); }
 	}
 	
 #endif
@@ -963,10 +938,6 @@ public class MAPS
 		@Override
 		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } }
 		@Override
-		public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putFirst(key, value); } }
-		@Override
-		public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putLast(key, value); } }
-		@Override
 		public boolean moveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.moveToFirst(key); } }
 		@Override
 		public boolean moveToLast(KEY_TYPE key) { synchronized(mutex) { return map.moveToLast(key); } }
@@ -987,25 +958,13 @@ public class MAPS
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() { synchronized(mutex) { return map.LAST_ENTRY_VALUE(); } }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { synchronized(mutex) { return map.firstEntry(); } }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { synchronized(mutex) { return map.lastEntry(); } }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } }
-		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } }
-		@Override
 		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { synchronized(mutex) { return map.copy(); } }
 		@Override
 		public ORDERED_SET KEY_GENERIC_TYPE keySet() {
 			if(keys == null) keys = SETS.synchronize(map.keySet(), mutex);
 			return (ORDERED_SET KEY_GENERIC_TYPE)keys;
 		}
-		@Override
+		
-		public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
-			if(values == null) values = VALUE_COLLECTIONS.synchronize(map.values(), mutex);
-			return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)values;
-		}
 		@Override
 		public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 			if(entrySet == null) entrySet = ObjectSets.synchronize(map.ENTRY_SET(), mutex);

src/builder/resources/speiger/assets/testers/templates/builder/OrderedSetTestSuiteBuilder.template

@@ -1,29 +1,16 @@
 package speiger.src.testers.PACKAGE.builder;
 
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 
 import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
 import com.google.common.collect.testing.Helpers;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.SampleElements;
 import com.google.common.collect.testing.features.CollectionFeature;
-import com.google.common.collect.testing.features.Feature;
 
 import junit.framework.TestSuite;
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
-import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
-import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
-import speiger.src.collections.PACKAGE.utils.LISTS;
 import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
 import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetMoveTester;
 import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetIterationTester;
 import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetNavigationTester;
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-import speiger.src.testers.utils.SpecialFeature;
 
 @SuppressWarnings("javadoc")
 public class ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER KEY_GENERIC_TYPE {
@@ -48,68 +35,4 @@ public class ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER
 #endignore
 		return super.createTestSuite();
 	}
-	
-	@Override
-	protected List<TestSuite> createDerivedSuites(
-			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
-		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
-
-		if (!parentBuilder.getFeatures().contains(SpecialFeature.REVERSE)) {
-			derivedSuites.add(createReverseSuite(parentBuilder));
-		}
-
-		return derivedSuites;
-	}
-
-	private TestSuite createReverseSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
-		TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE delegate = (TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
-
-		List<Feature<?>> features = new ArrayList<>();
-		features.add(SpecialFeature.REVERSE);
-		features.addAll(parentBuilder.getFeatures());
-		features.remove(SpecialFeature.COPYING);
-		features.remove(SpecialFeature.CHILDREN_COPY);
-		
-		return ORDERED_SET_TEST_BUILDER.using(new TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE() {
-			@Override
-			public SampleElements<CLASS_TYPE> samples() {
-				return delegate.samples();
-			}
-			
-			@Override
-			public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
-				return delegate.getSamples();
-			}
-
-			@Override
-			public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
-				return insertionOrder;
-			}
-
-			@Override
-			public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
-				return insertionOrder;
-			}
-			
-#if !TYPE_OBJECT
-			@Override
-			public ORDERED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
-				LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES(elements);
-				LISTS.reverse(list);
-				return delegate.create(list.TO_ARRAY()).reversed();
-			}
-			
-#endif
-			@Override
-			public ORDERED_SET KEY_GENERIC_TYPE create(Object... elements) {
-				LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
-				for (Object e : elements) {
-					list.add(CLASS_TO_KEY(e));
-				}
-				LISTS.reverse(list);
-				return delegate.create(list.toArray()).reversed();
-			}
-		}).named(parentBuilder.getName() + " reversing").withFeatures(features)
-				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
-	}
 }

src/builder/resources/speiger/assets/testers/templates/builder/maps/MapTestSuiteBuilder.template

@@ -238,17 +238,21 @@ public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder
 	private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> mapFeatures) {
 		Set<Feature<?>> entrySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
 #ignore
-		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) entrySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) {
-
+			entrySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
-		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) entrySetFeatures.add(SpecialFeature.COPYING);
+		}
-		else entrySetFeatures.remove(SpecialFeature.COPYING);
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
-		
+			entrySetFeatures.add(SpecialFeature.COPYING);
-		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) entrySetFeatures.add(SpecialFeature.MODIFIABLE);
+		}
-		else entrySetFeatures.remove(SpecialFeature.MODIFIABLE);
+		else {
-		
+			entrySetFeatures.remove(SpecialFeature.COPYING);
-		if(mapFeatures.contains(SpecialFeature.REVERSE)) entrySetFeatures.add(SpecialFeature.REVERSE);
+		}
-		else entrySetFeatures.remove(SpecialFeature.REVERSE);
+		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) {
-		
+			entrySetFeatures.add(SpecialFeature.MODIFIABLE);
+		}
+		else {
+			entrySetFeatures.remove(SpecialFeature.MODIFIABLE);
+		}
 		entrySetFeatures.add(SpecialFeature.MAP_ENTRY);
 #endignore
 		return entrySetFeatures;
@@ -258,17 +262,23 @@ public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder
 		Set<Feature<?>> keySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
 #ignore
 		keySetFeatures.add(CollectionFeature.SUBSET_VIEW);
-		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) {
-		else if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) keySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+			keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
-		
+		} else if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) {
-		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) keySetFeatures.add(SpecialFeature.COPYING);
+			keySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
-		else keySetFeatures.remove(SpecialFeature.COPYING);
+		}
-		
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
-		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) keySetFeatures.add(SpecialFeature.MODIFIABLE);
+			keySetFeatures.add(SpecialFeature.COPYING);
-		else keySetFeatures.remove(SpecialFeature.MODIFIABLE);
+		}
-		
+		else {
-		if(mapFeatures.contains(SpecialFeature.REVERSE)) keySetFeatures.add(SpecialFeature.REVERSE);
+			keySetFeatures.remove(SpecialFeature.COPYING);
-		else keySetFeatures.remove(SpecialFeature.REVERSE);
+		}
+		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) {
+			keySetFeatures.add(SpecialFeature.MODIFIABLE);
+		}
+		else {
+			keySetFeatures.remove(SpecialFeature.MODIFIABLE);
+		}
 #endignore
 		return keySetFeatures;
 	}
@@ -277,15 +287,18 @@ public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder
 	private static Set<Feature<?>> computeValuesCollectionFeatures(Set<Feature<?>> mapFeatures) {
 		Set<Feature<?>> valuesCollectionFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
 #ignore
-		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) {
-		
+			valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
-		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
+		}
-		
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) {
-		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) valuesCollectionFeatures.add(SpecialFeature.COPYING); 
+			valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
-		else valuesCollectionFeatures.remove(SpecialFeature.COPYING);
+		}
-		
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
-		if(mapFeatures.contains(SpecialFeature.REVERSE)) valuesCollectionFeatures.add(SpecialFeature.REVERSE);
+			valuesCollectionFeatures.add(SpecialFeature.COPYING);
-		else valuesCollectionFeatures.remove(SpecialFeature.REVERSE);
+		}
+		else {
+			valuesCollectionFeatures.remove(SpecialFeature.COPYING);
+		}
 #endignore
 		return valuesCollectionFeatures;
 	}

src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template

@@ -1,14 +1,9 @@
 package speiger.src.testers.PACKAGE.builder.maps;
 
-import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 
 import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
 import com.google.common.collect.testing.features.CollectionFeature;
-import com.google.common.collect.testing.features.Feature;
 
 import junit.framework.TestSuite;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
@@ -17,17 +12,14 @@ import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
 import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
 import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
 import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
-import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
 import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester;
 import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester;
 #if !TYPE_OBJECT
 import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder;
 import speiger.src.testers.objects.generators.TestObjectSetGenerator;
 import speiger.src.testers.objects.builder.ObjectOrderedSetTestSuiteBuilder;
 import speiger.src.testers.objects.generators.TestObjectOrderedSetGenerator;
 #endif
-import speiger.src.testers.utils.SpecialFeature;
 
 @SuppressWarnings("javadoc")
 public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE
@@ -42,7 +34,6 @@ public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BU
 		List<Class<? extends AbstractTester>> testers = super.getTesters();
 		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester.class);
 		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester.class);
 		return testers;
 	}
 	
@@ -54,15 +45,6 @@ public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BU
 		return super.createTestSuite();
 	}
 	
-	@Override
-	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
-		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
-		if (!parentBuilder.getFeatures().contains(SpecialFeature.REVERSE)) {
-			derivedSuites.add(createReverseSuite(parentBuilder));
-		}
-		return derivedSuites;
-	}
-	
 	protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) {
 		return ObjectOrderedSetTestSuiteBuilder.using((TestObjectOrderedSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySetGenerator);
 	}
@@ -70,17 +52,4 @@ public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BU
 	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
 		return ORDERED_SET_TEST_BUILDER.using((TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE)generator);
 	}
-	
-	private TestSuite createReverseSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
-		TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
-
-		List<Feature<?>> features = new ArrayList<>();
-		features.add(SpecialFeature.REVERSE);
-		features.addAll(parentBuilder.getFeatures());
-		features.remove(SpecialFeature.COPYING);
-		features.remove(SpecialFeature.CHILDREN_COPY);
-		return ORDERED_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.ReverseTestOrderedMapGeneratorKV_BRACES(delegate))
-				.named(parentBuilder.getName() + " reversed").withFeatures(features)
-				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
-	}
 }

src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template

@@ -20,7 +20,6 @@ import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP.Entry;
 import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.SET;
@@ -207,22 +206,6 @@ public class DERIVED_MAP_GENERATORS {
 		}
 	}
 	
-	public static class ReverseTestOrderedMapGenerator KEY_VALUE_GENERIC_TYPE extends MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE {
-		TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;
-		
-		public ReverseTestOrderedMapGenerator(TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent) {
-			super(parent);
-			this.parent = parent;
-		}
-		
-		@Override
-		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE create(Entry KEY_VALUE_GENERIC_TYPE... elements) {
-			ObjectList<Entry KEY_VALUE_GENERIC_TYPE> entries = new ObjectArrayList<Entry KEY_VALUE_GENERIC_TYPE>(elements);
-			ObjectLists.reverse(entries);
-			return ((ORDERED_MAP KEY_VALUE_GENERIC_TYPE)parent.create(entries.toArray(Entry[]::new))).reversed();
-		}
-	}
-	
 	public static class MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
 	{
 		TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;

src/builder/resources/speiger/assets/testers/templates/impl/maps/MapConstructorTests.template

@@ -27,8 +27,6 @@ import speiger.src.collections.PACKAGE.maps.impl.concurrent.CONCURRENT_HASH_MAP;
 #if TYPE_OBJECT
 import speiger.src.collections.PACKAGE.maps.impl.misc.ENUM_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.misc.LINKED_ENUM_MAP;
-import speiger.src.collections.PACKAGE.maps.impl.reference.REF_MAP;
-import speiger.src.collections.PACKAGE.maps.impl.reference.LINKED_REF_MAP;
 #endif
 
 import speiger.src.collections.PACKAGE.maps.impl.tree.RB_TREE_MAP;
@@ -136,97 +134,6 @@ public class MAP_CONSTRUCTOR_TESTS
 	}
 	
 #if TYPE_OBJECT
-	public static class RefMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
-	{
-		public RefMap() {
-			setSimpleConstructor(REF_MAP::new);
-			setSizeConstructor(REF_MAP::new);
-			setPArrayConstructor(REF_MAP::new);
-#if !TYPE_OBJECT || !VALUE_OBJECT
-			setArrayConstructor(REF_MAP::new);
-#endif
-			setPMapConstructor(REF_MAP::new);
-			setMapConstructor(REF_MAP::new);
-		}
-	
-		@Test
-		public void testWrongLoadFactorSize() {
-			setSizeConstructor(T -> new REF_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
-			try {
-				testSizeConstructor_smallSize();
-				fail("A Constructor using a 0 LoadFactor should error");
-			} catch(IllegalStateException e) {}
-		
-			setSizeConstructor(T -> new REF_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
-			try {
-				testSizeConstructor_smallSize();
-				fail("A Constructor using a 1 LoadFactor should error");
-			} catch(IllegalStateException e) {}
-		}
-	
-#if TYPE_OBJECT
-		@Override
-		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
-		
-#endif
-#if VALUE_OBJECT
-		@Override
-		protected String[] createValueElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
-		}
-		
-#endif
-	}
-	
-	public static class LinkedRefMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
-	{
-		public LinkedRefMap() {
-			setSimpleConstructor(LINKED_REF_MAP::new);
-			setSizeConstructor(LINKED_REF_MAP::new);
-			setPArrayConstructor(LINKED_REF_MAP::new);
-#if !TYPE_OBJECT || !VALUE_OBJECT
-			setArrayConstructor(LINKED_REF_MAP::new);
-#endif
-			setPMapConstructor(LINKED_REF_MAP::new);
-			setMapConstructor(LINKED_REF_MAP::new);
-		}
-		
-		@Test
-		public void testWrongLoadFactorSize() {
-			setSizeConstructor(T -> new LINKED_REF_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
-			try {
-				testSizeConstructor_smallSize();
-				fail("A Constructor using a 0 LoadFactor should error");
-			} catch(IllegalStateException e) {
-			}
-			
-			setSizeConstructor(T -> new LINKED_REF_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
-			try {
-				testSizeConstructor_smallSize();
-				fail("A Constructor using a 1 LoadFactor should error");
-			} catch(IllegalStateException e) {
-			}
-		}
-		
-#if TYPE_OBJECT
-		@Override
-		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
-		
-#endif
-#if VALUE_OBJECT
-		@Override
-		protected String[] createValueElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
-		}
-		
-#endif
-	}
-	
-	
 #if VALUE_OBJECT
 	public static class EnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum, String>
 #else

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionForEachTester.template

@@ -25,15 +25,6 @@ public class FILE_KEY_TYPECollectionForEachTester KEY_GENERIC_TYPE extends ABSTR
 		collection.forEach(elements::add);
 		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
 	}
-
-#ignore
-	@CollectionFeature.Require(absent = KNOWN_ORDER)
-	public void testIndexedForEachUnknownOrder() {
-#endignore
-		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
-		collection.forEachIndexed((K, V) -> elements.add(V));
-		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
-	}
 	
 #ignore
 @CollectionFeature.Require(absent = KNOWN_ORDER)
@@ -52,15 +43,6 @@ public class FILE_KEY_TYPECollectionForEachTester KEY_GENERIC_TYPE extends ABSTR
 		collection.forEach(elements::add);
 		assertEquals("Different ordered iteration", HELPERS.copyToList(getOrderedElements()), elements);
 	}
-
-#ignore
-	@CollectionFeature.Require(KNOWN_ORDER)
-	public void testIndexedForEachKnownOrder() {
-#endignore
-		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
-		collection.forEachIndexed((K, V) -> elements.add(V));
-		assertEquals("Different ordered iteration", HELPERS.copyToList(getOrderedElements()), elements);
-	}
 	
 #ignore
 	@CollectionFeature.Require(KNOWN_ORDER)

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableFindFirstTester.template

@@ -4,12 +4,6 @@ package speiger.src.testers.PACKAGE.tests.iterable;
 import java.util.Objects;
 
 #endif
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#else
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
-#endif
-
 import org.junit.Ignore;
 
 import com.google.common.collect.testing.features.CollectionSize;
@@ -33,17 +27,17 @@ public class FILE_KEY_TYPEIterableFindFirstTester KEY_GENERIC_TYPE extends ABSTR
 	@CollectionSize.Require(absent = CollectionSize.ZERO)
 #endignore
 	public void testIterableFindFirst_FindFirstElements() {
-		assertEquals("First Element should be found", e0(), container.findFirst(T -> KEY_EQUALS(T, e0())).SUPPLY_GET());
+		assertEquals("First Element should be found", e0(), container.findFirst(T -> KEY_EQUALS(T, e0())));
 	}
 	
 	public void testIterableFindFirst_FindNothing() {
-		assertEquals("No element should be found", OPTIONAL.empty(), container.findFirst(T -> KEY_EQUALS(T, e4())));
+		assertEquals("No element should be found", EMPTY_KEY_VALUE, container.findFirst(T -> KEY_EQUALS(T, e4())));
 	}
 	
 #ignore
 	@CollectionSize.Require(CollectionSize.SEVERAL)
 #endignore
 	public void testIterableFindFirst_FindLastElement() {
-		assertEquals("Last Element should be found", e2(), container.findFirst(T -> KEY_EQUALS(T, e2())).SUPPLY_GET());
+		assertEquals("Last Element should be found", e2(), container.findFirst(T -> KEY_EQUALS(T, e2())));
 	}
 }

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableReduceTester.template

@@ -3,16 +3,9 @@ package speiger.src.testers.PACKAGE.tests.iterable;
 #if TYPE_OBJECT
 import java.util.Objects;
 
-#endif
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#else
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 #endif
 import org.junit.Ignore;
 
-import com.google.common.collect.testing.features.CollectionSize;
-
 import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
 
 @Ignore
@@ -36,7 +29,7 @@ public class FILE_KEY_TYPEIterableReduceTester KEY_GENERIC_TYPE extends ABSTRACT
 	}
 	
 	public void testIterableReduce() {
-		assertEquals("The sum of the collection should match", size == CollectionSize.ZERO ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(getSum()), collection.reduce(this::sum));
+		assertEquals("The sum of the collection should match", getSum(), collection.reduce(this::sum));
 	}
 	
 	public void testIterableExtraReduce() {

src/builder/resources/speiger/assets/testers/templates/tests/maps/MapContainsTester.template

@@ -27,7 +27,6 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester KEY_VALUE_GENERIC_TY
 
 #ignore
 	@CollectionSize.Require(absent = ZERO)
-	@SuppressWarnings("unlikely-arg-type")
 #endignore
 	public void testContainsObject_yes() {
 		assertTrue("contains(present) should return true", getMap().ENTRY_SET().contains(new AbstractMap.SimpleEntry<>(e0())));
@@ -37,7 +36,6 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester KEY_VALUE_GENERIC_TY
 		assertFalse("contains(notPresent) should return false", getMap().ENTRY_SET().contains(e3()));
 	}
 	
-	@SuppressWarnings("unlikely-arg-type")
 	public void testContainsObject_no() {
 		assertFalse("contains(notPresent) should return false", getMap().ENTRY_SET().contains(new AbstractMap.SimpleEntry<>(e3())));
 	}

src/builder/resources/speiger/assets/testers/templates/tests/maps/MapRemoveEntryTester.template

@@ -136,7 +136,6 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester KEY_VALUE_GENERIC
 #ignore
 	@CollectionSize.Require(ONE)
 	@MapFeature.Require(SUPPORTS_REMOVE)
-	@SuppressWarnings("unlikely-arg-type")
 #endignore
 	public void testRemove_supportedObjectEntryPresent() {
 		assertTrue(getMap().ENTRY_SET().remove(new AbstractMap.SimpleEntry<>(e0())));
@@ -155,7 +154,6 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester KEY_VALUE_GENERIC
 #ignore
 	@CollectionSize.Require(ONE)
 	@MapFeature.Require(SUPPORTS_REMOVE)
-	@SuppressWarnings("unlikely-arg-type")
 #endignore
 	public void testRemove_supportedObjectEntryMissing() {
 		assertFalse(getMap().ENTRY_SET().remove(new AbstractMap.SimpleEntry<>(e3())));

src/builder/resources/speiger/assets/testers/templates/tests/maps/OrderedMapPutTester.template

@@ -1,118 +0,0 @@
-package speiger.src.testers.PACKAGE.tests.maps;
-
-#ignore
-import static com.google.common.collect.testing.features.CollectionSize.ZERO;
-import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_PUT;
-import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_REMOVE;
-import static org.junit.Assert.assertNotEquals;
-#endignore
-
-import com.google.common.collect.testing.features.CollectionSize;
-import com.google.common.collect.testing.features.MapFeature;
-
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
-import speiger.src.collections.objects.lists.ObjectList;
-import speiger.src.testers.PACKAGE.tests.base.maps.ABSTRACT_MAP_TESTER;
-import speiger.src.testers.objects.utils.ObjectHelpers;
-
-@SuppressWarnings("javadoc")
-public class FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP_TESTER KEY_VALUE_GENERIC_TYPE
-{
-	private ORDERED_MAP KEY_VALUE_GENERIC_TYPE orderedMap;
-	private ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> values;
-	private KEY_TYPE a;
-	private VALUE_TYPE aValue;
-	
-	@Override
-	public void setUp() throws Exception {
-		super.setUp();
-		orderedMap = (ORDERED_MAP KEY_VALUE_GENERIC_TYPE)getMap();
-		values = ObjectHelpers.copyToList(getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
-		if (values.size() >= 1) {
-			a = values.get(0).ENTRY_KEY();
-			aValue = values.get(0).ENTRY_VALUE();
-		}
-	}
-	
-#ignore
-	@MapFeature.Require(SUPPORTS_PUT)
-	@CollectionSize.Require(absent = ZERO)
-#endignore
-	public void testPutFirst() {
-		assertEquals(aValue, orderedMap.putFirst(a, v3()));
-		assertNotEquals(v3(), orderedMap.FIRST_ENTRY_VALUE());
-		assertEquals(orderedMap.getDefaultReturnValue(), orderedMap.putFirst(k4(), v4()));
-		assertEquals(v4(), orderedMap.FIRST_ENTRY_VALUE());
-		assertEquals(e4(), orderedMap.firstEntry());
-	}
-	
-
-#ignore
-	@MapFeature.Require(SUPPORTS_PUT)
-	@CollectionSize.Require(absent = ZERO)
-#endignore
-	public void testPutLast() {
-		assertEquals(aValue, orderedMap.putLast(a, v3()));
-		assertNotEquals(v3(), orderedMap.LAST_ENTRY_VALUE());
-		assertEquals(orderedMap.getDefaultReturnValue(), orderedMap.putLast(k4(), v4()));
-		assertEquals(v4(), orderedMap.LAST_ENTRY_VALUE());
-		assertEquals(e4(), orderedMap.lastEntry());
-	}
-	
-#ignore
-	@MapFeature.Require(SUPPORTS_REMOVE)
-	@CollectionSize.Require(CollectionSize.ONE)
-#endignore
-	public void testPollFirst() {
-		assertFalse(orderedMap.isEmpty());
-		assertEquals(e0(), orderedMap.pollFirstEntry());
-		assertTrue(orderedMap.isEmpty());
-	}
-	
-#ignore
-	@MapFeature.Require(SUPPORTS_REMOVE)
-	@CollectionSize.Require(CollectionSize.ONE)
-#endignore
-	public void testPollLast() {
-		assertFalse(orderedMap.isEmpty());
-		assertEquals(e0(), orderedMap.pollLastEntry());
-		assertTrue(orderedMap.isEmpty());
-	}
-	
-#ignore
-	@MapFeature.Require(absent = SUPPORTS_PUT)
-#endignore
-	public void testUnsupportedPutFirst() {
-		try { orderedMap.putFirst(a, aValue); }
-		catch (UnsupportedOperationException tolerated) {}
-		expectUnchanged();
-	}
-	
-#ignore
-	@MapFeature.Require(absent = SUPPORTS_PUT)
-#endignore
-	public void testUnsupportedPutLast() {
-		try { orderedMap.putLast(a, aValue); }
-		catch (UnsupportedOperationException tolerated) {}
-		expectUnchanged();
-	}
-	
-#ignore
-	@MapFeature.Require(absent = SUPPORTS_REMOVE)
-#endignore
-	public void testUnsupportedPollFirst() {
-		try { orderedMap.pollFirstEntry(); }
-		catch (UnsupportedOperationException tolerated) {}
-		expectUnchanged();
-	}
-	
-#ignore
-	@MapFeature.Require(absent = SUPPORTS_REMOVE)
-#endignore
-	public void testUnsupportedPollLast() {
-		try { orderedMap.pollFirstEntry(); }
-		catch (UnsupportedOperationException tolerated) {}
-		expectUnchanged();
-	}
-}

src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueFindFirstTester.template

@@ -2,11 +2,6 @@ package speiger.src.testers.PACKAGE.tests.queue.iterators;
 
 #if TYPE_OBJECT
 import java.util.Objects;
-#endif
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#else
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 
 #endif
 import org.junit.Ignore;
@@ -32,17 +27,17 @@ public class FILE_KEY_TYPEQueueFindFirstTester KEY_GENERIC_TYPE extends ABSTRACT
 	@CollectionSize.Require(absent = CollectionSize.ZERO)
 #endignore
 	public void testQueueFindFirst_FindFirstElements() {
-		assertEquals("First Element should be found", e0(), queue.findFirst(T -> KEY_EQUALS(T, e0())).SUPPLY_GET());
+		assertEquals("First Element should be found", e0(), queue.findFirst(T -> KEY_EQUALS(T, e0())));
 	}
 	
 	public void testQueueFindFirst_FindNothing() {
-		assertEquals("No element should be found", OPTIONAL.empty(), queue.findFirst(T -> KEY_EQUALS(T, e4())));
+		assertEquals("No element should be found", EMPTY_KEY_VALUE, queue.findFirst(T -> KEY_EQUALS(T, e4())));
 	}
 	
 #ignore
 	@CollectionSize.Require(CollectionSize.SEVERAL)
 #endignore
 	public void testQueueFindFirst_FindLastElement() {
-		assertEquals("Last Element should be found", e2(), queue.findFirst(T -> KEY_EQUALS(T, e2())).SUPPLY_GET());
+		assertEquals("Last Element should be found", e2(), queue.findFirst(T -> KEY_EQUALS(T, e2())));
 	}
 }

src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueReduceTester.template

@@ -3,16 +3,10 @@ package speiger.src.testers.PACKAGE.tests.queue.iterators;
 #if TYPE_OBJECT
 import java.util.Objects;
 
-#endif
-#if JDK_TYPE
-import java.util.OPTIONAL;
-#else
-import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 #endif
 import org.junit.Ignore;
 
 import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_QUEUE_TESTER;
-import com.google.common.collect.testing.features.CollectionSize;
 
 @Ignore
 @SuppressWarnings("javadoc")
@@ -35,7 +29,7 @@ public class FILE_KEY_TYPEQueueReduceTester KEY_GENERIC_TYPE extends ABSTRACT_QU
 	}
 	
 	public void testQueueReduce() {
-		assertEquals("The sum of the queue should match", size == CollectionSize.ZERO ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(getSum()), queue.reduce(this::sum));
+		assertEquals("The sum of the queue should match", getSum(), queue.reduce(this::sum));
 	}
 	
 	public void testQueueExtraReduce() {

src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetMoveTester.template

@@ -45,10 +45,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testaddMoveToFirstMissing()
 	{
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 		assertEquals(true, orderedSet.addAndMoveToFirst(e4()));
-		assertNotEquals(a, orderedSet.GET_FIRST_KEY());
+		assertNotEquals(a, orderedSet.FIRST_KEY());
-		assertEquals(e4(), orderedSet.GET_FIRST_KEY());
+		assertEquals(e4(), orderedSet.FIRST_KEY());
 	}
 	
 #ignore
@@ -57,10 +57,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testaddMoveToFirstPreset()
 	{
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 		assertEquals(false, orderedSet.addAndMoveToFirst(c));
-		assertNotEquals(a, orderedSet.GET_FIRST_KEY());
+		assertNotEquals(a, orderedSet.FIRST_KEY());
-		assertEquals(c, orderedSet.GET_FIRST_KEY());
+		assertEquals(c, orderedSet.FIRST_KEY());
 	}
 	
 #ignore
@@ -69,10 +69,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testaddMoveToLastMissing()
 	{
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 		assertEquals(true, orderedSet.addAndMoveToLast(e4()));
-		assertNotEquals(c, orderedSet.GET_LAST_KEY());
+		assertNotEquals(c, orderedSet.LAST_KEY());
-		assertEquals(e4(), orderedSet.GET_LAST_KEY());
+		assertEquals(e4(), orderedSet.LAST_KEY());
 	}
 	
 #ignore
@@ -81,10 +81,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testaddMoveToLastPreset()
 	{
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 		assertEquals(false, orderedSet.addAndMoveToLast(a));
-		assertNotEquals(c, orderedSet.GET_LAST_KEY());
+		assertNotEquals(c, orderedSet.LAST_KEY());
-		assertEquals(a, orderedSet.GET_LAST_KEY());
+		assertEquals(a, orderedSet.LAST_KEY());
 	}
 	
 #ignore
@@ -93,9 +93,9 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testMoveToFirstMissing()
 	{
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 		assertEquals(false, orderedSet.moveToFirst(e4()));
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 	}
 	
 #ignore
@@ -104,10 +104,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testMoveToFirstPreset()
 	{
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 		assertEquals(true, orderedSet.moveToFirst(c));
-		assertNotEquals(a, orderedSet.GET_FIRST_KEY());
+		assertNotEquals(a, orderedSet.FIRST_KEY());
-		assertEquals(c, orderedSet.GET_FIRST_KEY());
+		assertEquals(c, orderedSet.FIRST_KEY());
 	}
 	
 #ignore
@@ -116,9 +116,9 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testMoveToLastMissing()
 	{
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 		assertEquals(false, orderedSet.moveToLast(e4()));
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 	}
 	
 #ignore
@@ -127,10 +127,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testMoveToLastPreset()
 	{
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 		assertEquals(true, orderedSet.moveToLast(a));
-		assertNotEquals(c, orderedSet.GET_LAST_KEY());
+		assertNotEquals(c, orderedSet.LAST_KEY());
-		assertEquals(a, orderedSet.GET_LAST_KEY());
+		assertEquals(a, orderedSet.LAST_KEY());
 	}
 	
 #ignore
@@ -139,10 +139,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testMoveCenterToLast()
 	{
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 		assertTrue(orderedSet.moveToLast(e1()));
-		assertNotEquals(c, orderedSet.GET_LAST_KEY());
+		assertNotEquals(c, orderedSet.LAST_KEY());
-		assertEquals(e1(), orderedSet.GET_LAST_KEY());
+		assertEquals(e1(), orderedSet.LAST_KEY());
 	}
 	
 #ignore
@@ -151,10 +151,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testMoveCenterToFirst()
 	{
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 		assertTrue(orderedSet.moveToFirst(e1()));
-		assertNotEquals(c, orderedSet.GET_FIRST_KEY());
+		assertNotEquals(c, orderedSet.FIRST_KEY());
-		assertEquals(e1(), orderedSet.GET_FIRST_KEY());
+		assertEquals(e1(), orderedSet.FIRST_KEY());
 	}
 	
 #ignore
@@ -163,13 +163,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testMoveForthAndBack()
 	{
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 		assertTrue(orderedSet.moveToLast(e0()));
-		assertNotEquals(c, orderedSet.GET_LAST_KEY());
+		assertNotEquals(c, orderedSet.LAST_KEY());
-		assertEquals(a, orderedSet.GET_LAST_KEY());
+		assertEquals(a, orderedSet.LAST_KEY());
-		assertNotEquals(a, orderedSet.GET_FIRST_KEY());
+		assertNotEquals(a, orderedSet.FIRST_KEY());
 		assertTrue(orderedSet.moveToFirst(e0()));
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 	}
 	
 #ignore
@@ -178,13 +178,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testMoveBackAndForth()
 	{
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 		assertTrue(orderedSet.moveToFirst(e2()));
-		assertNotEquals(a, orderedSet.GET_FIRST_KEY());
+		assertNotEquals(a, orderedSet.FIRST_KEY());
-		assertEquals(c, orderedSet.GET_FIRST_KEY());
+		assertEquals(c, orderedSet.FIRST_KEY());
-		assertNotEquals(c, orderedSet.GET_LAST_KEY());
+		assertNotEquals(c, orderedSet.LAST_KEY());
 		assertTrue(orderedSet.moveToLast(e2()));
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 	}
 	
 #ignore
@@ -193,13 +193,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testAddForthAndBack()
 	{
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 		assertFalse(orderedSet.addAndMoveToLast(e0()));
-		assertNotEquals(c, orderedSet.GET_LAST_KEY());
+		assertNotEquals(c, orderedSet.LAST_KEY());
-		assertEquals(a, orderedSet.GET_LAST_KEY());
+		assertEquals(a, orderedSet.LAST_KEY());
-		assertNotEquals(a, orderedSet.GET_FIRST_KEY());
+		assertNotEquals(a, orderedSet.FIRST_KEY());
 		assertFalse(orderedSet.addAndMoveToFirst(e0()));
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 	}
 	
 #ignore
@@ -208,13 +208,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
 #endignore
 	public void testAddBackAndForth()
 	{
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 		assertFalse(orderedSet.addAndMoveToFirst(e2()));
-		assertNotEquals(a, orderedSet.GET_FIRST_KEY());
+		assertNotEquals(a, orderedSet.FIRST_KEY());
-		assertEquals(c, orderedSet.GET_FIRST_KEY());
+		assertEquals(c, orderedSet.FIRST_KEY());
-		assertNotEquals(c, orderedSet.GET_LAST_KEY());
+		assertNotEquals(c, orderedSet.LAST_KEY());
 		assertFalse(orderedSet.addAndMoveToLast(e2()));
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 	}
 	
 #ignore

src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetNavigationTester.template

@@ -68,7 +68,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 		int polled = 0;
 		int expectedPolls = orderedSet.size();
 		while(polled < expectedPolls) {
-			orderedSet.REMOVE_FIRST_KEY();
+			orderedSet.POLL_FIRST_KEY();
 			polled++;
 		}
 		assertTrue("Map should be empty", orderedSet.isEmpty());
@@ -82,7 +82,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 		int polled = 0;
 		int expectedPolls = orderedSet.size();
 		while(polled < expectedPolls) {
-			orderedSet.REMOVE_LAST_KEY();
+			orderedSet.POLL_LAST_KEY();
 			polled++;
 		}
 		assertTrue("Map should be empty", orderedSet.isEmpty());
@@ -94,8 +94,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 #endignore
 	public void testEmptySetPollFirst() {
 		try {
-			orderedSet.REMOVE_FIRST_KEY();
+			orderedSet.POLL_FIRST_KEY();
-			fail("OrderedSet.REMOVE_FIRST_KEY should throw NoSuchElementException");
+			fail("OrderedSet.POLL_FIRST_KEY should throw NoSuchElementException");
 		} catch (NoSuchElementException e) {
 		}
 		expectUnchanged();
@@ -107,8 +107,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 #endignore
 	public void testEmptySetPollLast() {
 		try {
-			orderedSet.REMOVE_LAST_KEY();
+			orderedSet.POLL_LAST_KEY();
-			fail("OrderedSet.REMOVE_LAST_KEY should throw NoSuchElementException");
+			fail("OrderedSet.POLL_LAST_KEY should throw NoSuchElementException");
 		} catch (NoSuchElementException e) {
 		}
 		expectUnchanged();
@@ -119,8 +119,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 #endignore
 	public void testUnsupportedSetPollFirst() {
 		try {
-			orderedSet.REMOVE_FIRST_KEY();
+			orderedSet.POLL_FIRST_KEY();
-			fail("OrderedSet.REMOVE_FIRST_KEY should throw UnsupportedOperationException");
+			fail("OrderedSet.POLL_FIRST_KEY should throw UnsupportedOperationException");
 		} catch (UnsupportedOperationException e) {
 		}
 		expectUnchanged();
@@ -131,8 +131,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 #endignore
 	public void testUnsupportedSetPollLast() {
 		try {
-			orderedSet.REMOVE_LAST_KEY();
+			orderedSet.POLL_LAST_KEY();
-			fail("OrderedSet.REMOVE_LAST_KEY should throw UnsupportedOperationException");
+			fail("OrderedSet.POLL_LAST_KEY should throw UnsupportedOperationException");
 		} catch (UnsupportedOperationException e) {
 		}
 		expectUnchanged();
@@ -143,7 +143,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 	@CollectionSize.Require(ONE)
 #endignore
 	public void testSingletonSetPollFirst() {
-		assertEquals(a, orderedSet.REMOVE_FIRST_KEY());
+		assertEquals(a, orderedSet.POLL_FIRST_KEY());
 		assertTrue(orderedSet.isEmpty());
 	}
 	
@@ -152,7 +152,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 	@CollectionSize.Require(ONE)
 #endignore
 	public void testSingletonSetPollLast() {
-		assertEquals(a, orderedSet.REMOVE_LAST_KEY());
+		assertEquals(a, orderedSet.POLL_LAST_KEY());
 		assertTrue(orderedSet.isEmpty());
 	}
 	
@@ -161,7 +161,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 	@CollectionSize.Require(SEVERAL)
 #endignore
 	public void testPollFirst() {
-		assertEquals(a, orderedSet.REMOVE_FIRST_KEY());
+		assertEquals(a, orderedSet.POLL_FIRST_KEY());
 		assertEquals(values.subList(1, values.size()), HELPERS.copyToList(orderedSet));
 	}
 
@@ -170,7 +170,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 	@CollectionSize.Require(SEVERAL)
 #endignore
 	public void testPollLast() {
-		assertEquals(c, orderedSet.REMOVE_LAST_KEY());
+		assertEquals(c, orderedSet.POLL_LAST_KEY());
 		assertEquals(values.subList(0, values.size()-1), HELPERS.copyToList(orderedSet));
 	}
 	
@@ -179,7 +179,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 #endignore
 	public void testPollFirstUnsupported() {
 		try {
-			orderedSet.REMOVE_FIRST_KEY();
+			orderedSet.POLL_FIRST_KEY();
 			fail();
 		} catch (UnsupportedOperationException e) {
 		}
@@ -190,7 +190,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 #endignore
 	public void testPollLastUnsupported() {
 		try {
-			orderedSet.REMOVE_LAST_KEY();
+			orderedSet.POLL_LAST_KEY();
 			fail();
 		} catch (UnsupportedOperationException e) {
 		}
@@ -201,7 +201,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 #endignore
 	public void testEmptySetFirst() {
 		try {
-			orderedSet.GET_FIRST_KEY();
+			orderedSet.FIRST_KEY();
 			fail();
 		} catch (NoSuchElementException e) {
 		}
@@ -212,7 +212,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 #endignore
 	public void testEmptySetLast() {
 		try {
-			orderedSet.GET_LAST_KEY();
+			orderedSet.LAST_KEY();
 			fail();
 		} catch (NoSuchElementException e) {
 		}
@@ -222,27 +222,27 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
 	@CollectionSize.Require(ONE)
 #endignore
 	public void testSingletonSetFirst() {
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 	}
 
 #ignore
 	@CollectionSize.Require(ONE)
 #endignore
 	public void testSingletonSetLast() {
-		assertEquals(a, orderedSet.GET_LAST_KEY());
+		assertEquals(a, orderedSet.LAST_KEY());
 	}
 
 #ignore
 	@CollectionSize.Require(SEVERAL)
 #endignore
 	public void testFirst() {
-		assertEquals(a, orderedSet.GET_FIRST_KEY());
+		assertEquals(a, orderedSet.FIRST_KEY());
 	}
 
 #ignore
 	@CollectionSize.Require(SEVERAL)
 #endignore
 	public void testLast() {
-		assertEquals(c, orderedSet.GET_LAST_KEY());
+		assertEquals(c, orderedSet.LAST_KEY());
 	}
 }

src/builder/resources/speiger/assets/tests/templates/collections/SetTests.template

@@ -12,9 +12,6 @@ import com.google.common.collect.testing.features.CollectionSize;
 import com.google.common.collect.testing.features.SetFeature;
 import com.google.common.collect.testing.features.Feature;
 #if TYPE_OBJECT
-import com.google.common.collect.testing.testers.CollectionAddTester;
-import com.google.common.collect.testing.testers.CollectionAddAllTester;
-import com.google.common.collect.testing.testers.CollectionCreationTester;
 import com.google.common.collect.testing.features.CollectionFeature;
 #endif
 import junit.framework.Test;
@@ -125,9 +122,6 @@ public class SET_TESTS extends TestCase
 #ignore
 			.withFeatures(getSizes(size)).withFeatures(features);
 		if(nullValues) builder.withFeatures(CollectionFeature.ALLOWS_NULL_VALUES);
-		builder.suppressing(CollectionAddTester.getAddNullUnsupportedMethod(), CollectionAddTester.getAddNullSupportedMethod());
-		builder.suppressing(CollectionAddAllTester.getAddAllNullUnsupportedMethod());
-		builder.suppressing(CollectionCreationTester.getCreateWithNullUnsupportedMethod());
 #endignore
 		return builder.createTestSuite();
 	}

src/builder/resources/speiger/assets/tests/templates/maps/MapTests.template

@@ -41,8 +41,6 @@ import speiger.src.collections.PACKAGE.maps.impl.misc.ARRAY_MAP;
 #if TYPE_OBJECT
 import speiger.src.collections.PACKAGE.maps.impl.misc.ENUM_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.misc.LINKED_ENUM_MAP;
-import speiger.src.collections.PACKAGE.maps.impl.reference.REF_MAP;
-import speiger.src.collections.PACKAGE.maps.impl.reference.LINKED_REF_MAP;
 #endif
 import speiger.src.collections.PACKAGE.maps.impl.tree.AVL_TREE_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.tree.RB_TREE_MAP;
@@ -106,7 +104,6 @@ public class MAP_TESTS extends TestCase
 #if TYPE_OBJECT
 		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.EnumMap.class));
 		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.LinkedEnumMap.class));
-		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.RefMap.class));
 #endif
 		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.CustomHashMap.class));
 		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.LinkedCustomHashMap.class));
@@ -133,29 +130,27 @@ public class MAP_TESTS extends TestCase
 	}
 	
 	public static void suite(TestSuite suite) {
-		suite.addTest(mapSuite("HASH_MAP", HASH_MAP::new, getFeatures(), -1, true, true));
+		suite.addTest(mapSuite("HASH_MAP", HASH_MAP::new, getFeatures(), -1, true));
-		suite.addTest(orderedMapSuite("LINKED_HASH_MAP", LINKED_HASH_MAP::new, getFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("LINKED_HASH_MAP", LINKED_HASH_MAP::new, getFeatures(), -1));
-		suite.addTest(orderedMapSuite("IMMUTABLE_HASH_MAP", IMMUTABLE_HASH_MAP::new, getImmutableFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("IMMUTABLE_HASH_MAP", IMMUTABLE_HASH_MAP::new, getImmutableFeatures(), -1));
 #if TYPE_OBJECT
 		suite.addTest(enumMapSuite("ENUM_MAP", ENUM_MAP::new, getFeatures(), 5));
 		suite.addTest(enumOrderedMapSuite("LINKED_ENUM_MAP", (K, V) -> K.length <= 0 ? new LINKED_ENUM_MAP<>(AnEnum.class) : new LINKED_ENUM_MAP<>(K, V), getFeatures(), 5));
-		suite.addTest(mapSuite("REF_MAP", REF_MAP::new, getFeatures(), - 1, true, false));
-		suite.addTest(orderedMapSuite("LINKED_REF_MAP", LINKED_REF_MAP::new, getFeatures(), - 1, false));
 #endif
-		suite.addTest(mapSuite("CUSTOM_HASH_MAP", (K, V) -> new CUSTOM_HASH_MAPKV_BRACES(K, V, HashStrategy.INSTANCE), getFeatures(), -1, true, true));
+		suite.addTest(mapSuite("CUSTOM_HASH_MAP", (K, V) -> new CUSTOM_HASH_MAPKV_BRACES(K, V, HashStrategy.INSTANCE), getFeatures(), -1, true));
-		suite.addTest(orderedMapSuite("LINKED_CUSTOM_HASH_MAP", (K, V) -> new LINKED_CUSTOM_HASH_MAPKV_BRACES(K, V, HashStrategy.INSTANCE), getFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("LINKED_CUSTOM_HASH_MAP", (K, V) -> new LINKED_CUSTOM_HASH_MAPKV_BRACES(K, V, HashStrategy.INSTANCE), getFeatures(), -1));
-		suite.addTest(orderedMapSuite("ARRAY_MAP", ARRAY_MAP::new, getFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("ARRAY_MAP", ARRAY_MAP::new, getFeatures(), -1));
 		suite.addTest(concurrentMapSuite("CONCURRENT_HASH_MAP", CONCURRENT_HASH_MAP::new, getFeatures(), 2));
 		suite.addTest(concurrentMapSuite("CONCURRENT_HASH_MAP", CONCURRENT_HASH_MAP::new, getFeatures(), 3));
 		suite.addTest(navigableMapSuite("RB_TREE_MAP", RB_TREE_MAP::new, getFeatures(), -1));
 		suite.addTest(navigableMapSuite("AVL_TREE_MAP", AVL_TREE_MAP::new, getFeatures(), -1));
 		suite.addTest(navigableMapSuite("SynchronizedRB_TREE_MAP", (K, V) -> new RB_TREE_MAPKV_BRACES(K, V).synchronize(), getLimitedFeatures(), -1));
 		suite.addTest(navigableMapSuite("UnmodifiableRB_TREE_MAP", (K, V) -> new RB_TREE_MAPKV_BRACES(K, V).unmodifiable(), getLimitedImmutableFeatures(), -1));
-		suite.addTest(orderedMapSuite("SynchronizedORDERED_MAP", (K, V) -> new LINKED_HASH_MAPKV_BRACES(K, V).synchronize(), getFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("SynchronizedORDERED_MAP", (K, V) -> new LINKED_HASH_MAPKV_BRACES(K, V).synchronize(), getFeatures(), -1));
-		suite.addTest(orderedMapSuite("UnmodifiableORDERED_MAP", (K, V) -> new LINKED_HASH_MAPKV_BRACES(K, V).unmodifiable(), getImmutableFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("UnmodifiableORDERED_MAP", (K, V) -> new LINKED_HASH_MAPKV_BRACES(K, V).unmodifiable(), getImmutableFeatures(), -1));
-		suite.addTest(mapSuite("EmptyMAP", (K, V) -> MAPS.empty(), getEmptyFeatures(), 0, false, true));
+		suite.addTest(mapSuite("EmptyMAP", (K, V) -> MAPS.empty(), getEmptyFeatures(), 0, false));
-		suite.addTest(mapSuite("SingletonMAP", (K, V) -> MAPS.singleton(K[0], V[0]), getEmptyFeatures(), 1, false, true));
+		suite.addTest(mapSuite("SingletonMAP", (K, V) -> MAPS.singleton(K[0], V[0]), getEmptyFeatures(), 1, false));
-		suite.addTest(mapSuite("AbstractMap", SIMPLE_TEST_MAP::new, getTestFeatures(), -1, false, true));
+		suite.addTest(mapSuite("AbstractMap", SIMPLE_TEST_MAP::new, getTestFeatures(), -1, false));
 	}
 	
 #if TYPE_OBJECT
@@ -214,14 +209,14 @@ public class MAP_TESTS extends TestCase
 	
 #endif
 	
-	private static Test mapSuite(String name, BiFunction<KEY_STRING_TYPE[], VALUE_STRING_TYPE[], MAP KEY_VALUE_STRING_GENERIC_TYPE> factory, Collection<Feature<?>> features, int size, boolean sorted, boolean allowNullKeys) {
+	private static Test mapSuite(String name, BiFunction<KEY_STRING_TYPE[], VALUE_STRING_TYPE[], MAP KEY_VALUE_STRING_GENERIC_TYPE> factory, Collection<Feature<?>> features, int size, boolean sorted) {
 		SIMPLE_MAP_TEST_GENERATOR.Maps KEY_VALUE_STRING_GENERIC_TYPE generator = new SIMPLE_MAP_TEST_GENERATOR.Maps KEY_VALUE_STRING_GENERIC_TYPE(factory);
 		MAP_TEST_BUILDER KEY_VALUE_STRING_GENERIC_TYPE builder = MAP_TEST_BUILDER.using(generator);
 		builder.shouldBlockKeys(sorted);
 #if TYPE_OBJECT
 		generator.setKeys(createKeys());
 #ignore
-		if(allowNullKeys) builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS);
+		builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS);
 #endignore
 #endif
 #if VALUE_OBJECT
@@ -270,13 +265,13 @@ public class MAP_TESTS extends TestCase
 		return builder.named(name).createTestSuite();
 	}
 	
-	private static Test orderedMapSuite(String name, BiFunction<KEY_STRING_TYPE[], VALUE_STRING_TYPE[], ORDERED_MAP KEY_VALUE_STRING_GENERIC_TYPE> factory, Collection<Feature<?>> features, int size, boolean allowNullKeys) {
+	private static Test orderedMapSuite(String name, BiFunction<KEY_STRING_TYPE[], VALUE_STRING_TYPE[], ORDERED_MAP KEY_VALUE_STRING_GENERIC_TYPE> factory, Collection<Feature<?>> features, int size) {
 		SIMPLE_MAP_TEST_GENERATOR.OrderedMaps KEY_VALUE_STRING_GENERIC_TYPE generator = new SIMPLE_MAP_TEST_GENERATOR.OrderedMaps KEY_VALUE_STRING_GENERIC_TYPE(factory);
 		ORDERED_MAP_TEST_BUILDER KEY_VALUE_STRING_GENERIC_TYPE builder = ORDERED_MAP_TEST_BUILDER.using(generator);
 #if TYPE_OBJECT
 		generator.setKeys(createKeys());
 #ignore
-		if(allowNullKeys) builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS);
+		builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS);
 #endignore
 #endif
 #if VALUE_OBJECT

src/main/java/speiger/src/collections/booleans/collections/AbstractBooleanCollection.java

@@ -1,318 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Collection;
-import java.util.function.Supplier;
-import java.util.Objects;
-import java.util.AbstractCollection;
-
-import speiger.src.collections.booleans.lists.BooleanListIterator;
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-import speiger.src.collections.booleans.utils.BooleanIterators;
-import speiger.src.collections.booleans.utils.BooleanArrays;
-
-/**
- * Abstract Type Specific Collection that reduces boxing/unboxing
- */
-public abstract class AbstractBooleanCollection extends AbstractCollection<Boolean> implements BooleanCollection
-{
-	@Override
-	public abstract BooleanIterator iterator();
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public boolean add(Boolean e) { return BooleanCollection.super.add(e); }
-
-	@Override
-	public boolean addAll(BooleanCollection c) {
-		boolean modified = false;
-		for(BooleanIterator iter = c.iterator();iter.hasNext();modified |= add(iter.nextBoolean()));
-		return modified;
-	}
-	
-	@Override
-	public BooleanCollection copy() { throw new UnsupportedOperationException(); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public boolean contains(Object e) { return BooleanCollection.super.contains(e); }
-	
-	/**
-	 * A Type-Specific implementation of contains. This implementation iterates over the elements and returns true if the value match.
-	 * @param e the element that should be searched for.
-	 * @return true if the value was found.
-	 */
-	@Override
-	public boolean contains(boolean e) {
-		for(BooleanIterator iter = iterator();iter.hasNext();) { if(iter.nextBoolean() == e) return true; }
-		return false;
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public boolean addAll(Collection<? extends Boolean> c)
-	{
-		return c instanceof BooleanCollection ? addAll((BooleanCollection)c) : super.addAll(c);
-	}
-	
-	/**
-	 * A Type-Specific implementation of containsAll. This implementation iterates over all elements and checks all elements are present in the other collection.
-	 * @param c the collection that should be checked if it contains all elements.
-	 * @return true if all elements were found in the collection
-	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	public boolean containsAll(BooleanCollection c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return true;
-		for(BooleanIterator iter = c.iterator();iter.hasNext();)
-			if(!contains(iter.nextBoolean()))
-				return false;
-		return true;
-	}
-	
-	@Override
-	public boolean containsAll(Collection<?> c) {
-		Objects.requireNonNull(c);
-		return c instanceof BooleanCollection ? containsAll((BooleanCollection)c) : super.containsAll(c);
-	}
-	
-	/**
-	 * This implementation iterates over the elements of the collection and checks if they are stored in this collection
-	 * @param c the elements that should be checked for
-	 * @return true if any element is in this collection
-	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	@Deprecated
-	public boolean containsAny(Collection<?> c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return false;
-		for(Object e : c) 
-			if(contains(e))
-				return true;
-		return false;
-	}
-	
-	/**
-	 * This implementation iterates over the elements of the collection and checks if they are stored in this collection.
-	 * @param c the elements that should be checked for
-	 * @return true if any element is in this collection
- 	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	public boolean containsAny(BooleanCollection c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return false;
-		for(BooleanIterator iter = c.iterator();iter.hasNext();) 
-			if(contains(iter.nextBoolean()))
-				return true;
-		return false;
-	}
-		
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public boolean remove(Object e) { return BooleanCollection.super.remove(e); }
-	
-	/**
-	 * A Type-Specific implementation of remove. This implementation iterates over the elements until it finds the element that is searched for or it runs out of elements.
-	 * It stops after finding the first element
-	 * @param e the element that is searched for
-	 * @return true if the element was found and removed.
-	 */
-	@Override
-	public boolean remBoolean(boolean e) {
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(iter.nextBoolean() == e) {
-				iter.remove();
-				return true;
-			}
-		}
-		return false;
-	}
-	
-	/**
-	 * A Type-Specific implementation of removeAll. This Implementation iterates over all elements and removes them as they were found in the other collection.
-	 * @param c the elements that should be deleted
-	 * @return true if the collection was modified.
-	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	public boolean removeAll(BooleanCollection c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return false;
-		boolean modified = false;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(c.contains(iter.nextBoolean())) {
-				iter.remove();
-				modified = true;
-			}
-		}
-		return modified;
-	}
-
-	@Override
-	public boolean removeAll(BooleanCollection c, BooleanConsumer r) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return false;
-		Objects.requireNonNull(r);
-		boolean modified = false;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			boolean e = iter.nextBoolean();
-			if(c.contains(e)) {
-				r.accept(e);
-				iter.remove();
-				modified = true;
-			}
-		}
-		return modified;
-	}
-	
-	/**
-	 * A Type-Specific implementation of retainAll. This Implementation iterates over all elements and removes them as they were not found in the other collection.
-	 * @param c the elements that should be kept
-	 * @return true if the collection was modified.
-	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	public boolean retainAll(BooleanCollection c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) {
-			boolean modified = !isEmpty();
-			clear();
-			return modified;
-		}
-		boolean modified = false;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(!c.contains(iter.nextBoolean())) {
-				iter.remove();
-				modified = true;
-			}
-		}
-		return modified;
-	}
-	
-	@Override
-	public boolean retainAll(BooleanCollection c, BooleanConsumer r) {
-		Objects.requireNonNull(c);
-		Objects.requireNonNull(r);
-		if(c.isEmpty()) {
-			boolean modified = !isEmpty();
-			forEach(r);
-			clear();
-			return modified;
-		}
-		boolean modified = false;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			boolean e = iter.nextBoolean();
-			if(!c.contains(e)) {
-				r.accept(e);
-				iter.remove();
-				modified = true;
-			}
-		}
-		return modified;
-	}
-	
-	/**
-	 * A Type-Specific implementation of toArray that links to {@link #toBooleanArray(boolean[])} with a newly created array.
-	 * @return an array containing all of the elements in this collection
-	 */
-	@Override
-	public boolean[] toBooleanArray() {
-		if(isEmpty()) return BooleanArrays.EMPTY_ARRAY;
-		return toBooleanArray(new boolean[size()]);
-	}
-	
-	/**
-	 * A Type-Specific implementation of toArray. This implementation iterates over all elements and unwraps them into primitive type.
-	 * @param a array that the elements should be injected to. If null or to small a new array with the right size is created
-	 * @return an array containing all of the elements in this collection
-	 */
-	@Override
-	public boolean[] toBooleanArray(boolean[] a) {
-		if(a == null || a.length < size()) a = new boolean[size()];
-		BooleanIterators.unwrap(a, iterator());
-		if (a.length > size()) a[size()] = false;
-		return a;
-	}
-
-	public static class ReverseBooleanOrderedCollection extends AbstractBooleanCollection implements BooleanOrderedCollection {
-		BooleanOrderedCollection collection;
-		Supplier<BooleanIterator> reverseIterator;
-		
-		public ReverseBooleanOrderedCollection(BooleanOrderedCollection collection, Supplier<BooleanIterator> reverseIterator) {
-			this.collection = collection;
-			this.reverseIterator = reverseIterator;
-		}
-		
-		@Override
-		public boolean add(boolean o) { return collection.add(o); }
-		@Override
-		public BooleanOrderedCollection reversed() { return collection; }
-		@Override
-		public void addFirst(boolean e) { collection.addLast(e); }
-		@Override
-		public void addLast(boolean e) { collection.addFirst(e); }
-		@Override
-		public boolean contains(boolean e) { return collection.contains(e); }
-		@Override
-		public boolean remBoolean(boolean e) { return collection.remBoolean(e); }
-		@Override
-		public void clear() { collection.clear(); }
-		@Override
-		public boolean getFirstBoolean() { return collection.getLastBoolean(); }
-		@Override
-		public boolean removeFirstBoolean() { return collection.removeLastBoolean(); }
-		@Override
-		public boolean getLastBoolean() { return collection.getFirstBoolean(); }
-		@Override
-		public boolean removeLastBoolean() { return collection.removeFirstBoolean(); }
-		@Override
-		public BooleanIterator iterator() { return reverseIterator.get(); }
-		@Override
-		public int size() { return collection.size(); }
-	}
-	
-	public static class ReverseBiIterator implements BooleanListIterator {
-		BooleanListIterator it;
-		
-		public ReverseBiIterator(BooleanListIterator it) {
-			this.it = it;
-		}
-		
-		@Override
-		public boolean nextBoolean() { return it.previousBoolean(); }
-		@Override
-		public boolean hasNext() { return it.hasPrevious(); }
-		@Override
-		public boolean hasPrevious() { return it.hasNext(); }
-		@Override
-		public boolean previousBoolean() { return it.nextBoolean(); }
-		@Override
-		public void remove() { it.remove(); }
-		@Override
-		public int nextIndex() { return it.previousIndex(); }
-		@Override
-		public int previousIndex() { return it.nextIndex(); }
-		@Override
-		public void set(boolean e) { it.set(e); }
-		@Override
-		public void add(boolean e) { it.add(e); }
-	}
-}

src/main/java/speiger/src/collections/booleans/collections/BooleanBidirectionalIterator.java

@@ -1,52 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-/**
- * 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.
- */
-public interface BooleanBidirectionalIterator extends BooleanIterator
-{
-	/**
-	 * Returns true if the Iterator has a Previous element
-	 * @return true if the Iterator has a Previous element
-	 */
-	public boolean hasPrevious();
-	
-	/**
-	 * Returns the Previous element of the iterator.
-	 * @return the Previous element of the iterator.
- 	 * @throws java.util.NoSuchElementException if the iteration has no more elements
-	 */
-	public boolean previousBoolean();
-	
-	/**
-	 * <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.+
-	 */
-	@Deprecated
-	public default Boolean previous() {
-		return Boolean.valueOf(previousBoolean());
-	}
-	
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override
-	default int skip(int amount)
-	{
-		return BooleanIterator.super.skip(amount);
-	}
-	
-	/**
-	 * Reverses the Given amount of elements if possible. A Optimization function to reverse elements faster if the implementation allows it.
-	 * @param amount the amount of elements that should be reversed
-	 * @return the amount of elements that were reversed
-	 */
-	public default int back(int amount) {
-		if(amount < 0) throw new IllegalStateException("Can't go forward");
-		int i = 0;
-		for(;i<amount && hasPrevious();previousBoolean(),i++);
-		return i;
-	}
-}

src/main/java/speiger/src/collections/booleans/collections/BooleanCollection.java

@@ -1,231 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Collection;
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-import speiger.src.collections.booleans.utils.BooleanSplititerators;
-import speiger.src.collections.booleans.utils.BooleanCollections;
-import speiger.src.collections.utils.ISizeProvider;
-import speiger.src.collections.utils.SanityChecks;
-
-/**
- * A Type-Specific {@link Collection} that reduces (un)boxing
- */
-public interface BooleanCollection extends Collection<Boolean>, BooleanIterable, ISizeProvider
-{
-	/**
-	 * A Type-Specific add function to reduce (un)boxing
-	 * @param o the element that should be added
-	 * @return true if the element was added to the collection
-	 */
-	public boolean add(boolean o);
-	
-	/**
-	 * A Type-Specific addAll function to reduce (un)boxing
-	 * @param c the collection of elements that should be added
-	 * @return true if elements were added into the collection
-	 */
-	public boolean addAll(BooleanCollection c);
-	
-	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
-	 * @return if the collection was modified
-	 */
-	public default boolean addAll(boolean... e) { return addAll(e, 0, e.length); }
-	
-	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
-	 * @param length how many elements of the array should be added
-	 * @return if the collection was modified
-	 */
-	public default boolean addAll(boolean[] e, int length) { return addAll(e, 0, length); }
-	
-	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
-	 * @param offset where to start within the array
-	 * @param length how many elements of the array should be added
-	 * @return if the collection was modified
-	 */
-	public default boolean addAll(boolean[] e, int offset, int length) {
-		if(length <= 0) return false;
-		SanityChecks.checkArrayCapacity(e.length, offset, length);
-		boolean added = false;
-		for(int i = 0;i<length;i++) {
-			if(add(e[offset+i])) added = true;
-		}
-		return added;
-	}
-	
-	/**
-	 * A Type-Specific contains function to reduce (un)boxing
-	 * @param o the element that is checked for
-	 * @return true if the element is found in the collection
-	 */
-	public boolean contains(boolean o);
-	
-	/**
- 	 * A Type-Specific containsAll function to reduce (un)boxing
- 	 * @param c the collection of elements that should be tested for
- 	 * @return true if all the element is found in the collection
- 	 */
-	public boolean containsAll(BooleanCollection c);
-	
-	/**
-	 * A Type-Specific containsAny function to reduce (un)boxing
- 	 * @param c the collection of elements that should be tested for
-	 * @return true if any element was found
-	 */
-	public boolean containsAny(BooleanCollection c);
-	
-	/**
-	 * Returns true if any element of the Collection is found in the provided collection.
-	 * A Small Optimization function to find out of any element is present when comparing collections and not all of them.
- 	 * @param c the collection of elements that should be tested for
-	 * @return true if any element was found.
-	 */
-	@Deprecated
-	public boolean containsAny(Collection<?> c);
-	
-	/**
-	 * A Type-Specific remove function that reduces (un)boxing.
-	 * @param o the element that should be removed
-	 * @return true if the element was removed
-	 * @see Collection#remove(Object)
-	 */
-	public boolean remBoolean(boolean o);
-	
-	/**
-	 * A Type-Specific removeAll function that reduces (un)boxing.
-	 * @param c the collection of elements that should be removed
-	 * @return true if any element was removed
-	 * @see Collection#removeAll(Collection)
-	 */
-	public boolean removeAll(BooleanCollection c);
-	
-	/**
-	 * A Type-Specific removeAll function that reduces (un)boxing.
-	 * It also notifies the remover of which exact element is going to be removed.
-	 * @param c the collection of elements that should be removed
-	 * @param r elements that got removed
-	 * @return true if any element was removed
-	 * @see Collection#removeAll(Collection)
-	 */
-	public boolean removeAll(BooleanCollection c, BooleanConsumer r);
-	
-	/**
- 	 * A Type-Specific retainAll function that reduces (un)boxing.
-	 * @param c the collection of elements that should be kept
- 	 * @return true if any element was removed
- 	 * @see Collection#retainAll(Collection)
- 	 */
-	public boolean retainAll(BooleanCollection c);
-	
-	/**
- 	 * A Type-Specific retainAll function that reduces (un)boxing.
-	 * It also notifies the remover of which exact element is going to be removed.
-	 * @param c the collection of elements that should be kept
-	 * @param r elements that got removed
- 	 * @return true if any element was removed
- 	 * @see Collection#retainAll(Collection)
- 	 */
-	public boolean retainAll(BooleanCollection c, BooleanConsumer r);
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to collect all elements
-	 * @param collection that the elements should be inserted to
-	 * @param <E> the collection type
-	 * @return the input with the desired elements
-	 */
-	default <E extends BooleanCollection> E pour(E collection) {
-		collection.addAll(this);
-		return collection;
-	}
-	
-	/**
-	 * A Function that does a shallow clone of the Collection itself.
-	 * This function is more optimized then a copy constructor since the Collection does not have to be unsorted/resorted.
-	 * It can be compared to Cloneable but with less exception risk
-	 * @return a Shallow Copy of the collection
-	 * @note Wrappers and view collections will not support this feature
-	 */
-	public BooleanCollection copy();
-	
-	/**
-	 * A Type-Specific toArray function that delegates to {@link #toBooleanArray(boolean[])} with a newly created array.
-	 * @return an array containing all of the elements in this collection
-	 * @see Collection#toArray()
-	 */
-	public boolean[] toBooleanArray();
-	
-	/**
-	 * A Type-Specific toArray function that reduces (un)boxing.
-	 * @param a array that the elements should be injected to. If null or to small a new array with the right size is created
-	 * @return an array containing all of the elements in this collection
-	 * @see Collection#toArray(Object[])
-	 */
-	public boolean[] toBooleanArray(boolean[] a);
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public default boolean add(Boolean o) { return add(o.booleanValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public default boolean contains(Object o) { return o != null && contains(((Boolean)o).booleanValue()); }
-	
-	/** {@inheritDoc}
- 	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	public default boolean remove(Object o) { return o != null && remBoolean(((Boolean)o).booleanValue()); }
-	
-	/**
-	 * Returns a Type-Specific Iterator to reduce (un)boxing
-	 * @return a iterator of the collection
-	 * @see Collection#iterator()
-	 */
-	@Override
-	public BooleanIterator iterator();
-	
-	/**
-	 * Creates a Wrapped Collection that is Synchronized
-	 * @return a new Collection that is synchronized
-	 * @see BooleanCollections#synchronize
-	 */
-	public default BooleanCollection synchronize() { return BooleanCollections.synchronize(this); }
-	
-	/**
-	 * Creates a Wrapped Collection that is Synchronized
-	 * @param mutex is the controller of the synchronization block
-	 * @return a new Collection Wrapper that is synchronized
-	 * @see BooleanCollections#synchronize
-	 */
-	public default BooleanCollection synchronize(Object mutex) { return BooleanCollections.synchronize(this, mutex); }
-	
-	/**
-	 * Creates a Wrapped Collection that is unmodifiable
-	 * @return a new Collection Wrapper that is unmodifiable
-	 * @see BooleanCollections#unmodifiable
-	 */
-	public default BooleanCollection unmodifiable() { return BooleanCollections.unmodifiable(this); }
-	
-
-	/**
-	 * A Type Specific Type Splititerator to reduce boxing/unboxing
-	 * @return type specific splititerator
-	 */
-	@Override
-	default BooleanSplititerator spliterator() { return BooleanSplititerators.createSplititerator(this, 0); }
-}

src/main/java/speiger/src/collections/booleans/collections/BooleanIterable.java

@@ -1,334 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Objects;
-import java.util.function.Consumer;
-
-
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-import speiger.src.collections.booleans.functions.BooleanComparator;
-import speiger.src.collections.objects.collections.ObjectIterable;
-import speiger.src.collections.booleans.functions.OptionalBoolean;
-import speiger.src.collections.booleans.functions.function.BooleanFunction;
-import speiger.src.collections.ints.functions.consumer.IntBooleanConsumer;
-import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer;
-import speiger.src.collections.booleans.functions.function.BooleanPredicate;
-import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator;
-import speiger.src.collections.booleans.lists.BooleanList;
-import speiger.src.collections.booleans.lists.BooleanArrayList;
-import speiger.src.collections.booleans.utils.BooleanArrays;
-import speiger.src.collections.booleans.utils.BooleanAsyncBuilder;
-import speiger.src.collections.booleans.utils.BooleanSplititerators;
-import speiger.src.collections.booleans.utils.BooleanIterables;
-import speiger.src.collections.booleans.utils.BooleanIterators;
-import speiger.src.collections.utils.ISizeProvider;
-
-/**
- * A Type-Specific {@link Iterable} that reduces (un)boxing
- */
-public interface BooleanIterable extends Iterable<Boolean>
-{
-	/**
-	 * Returns an iterator over elements of type {@code T}.
-	 *
-	 * @return an Iterator.
-	 */
-	@Override
-	BooleanIterator iterator();
-	
-	/**
-	 * A Type Specific foreach function that reduces (un)boxing
-	 * 
-	 * @implSpec
-	 * <p>The default implementation behaves as if:
-	 * <pre>{@code
-	 *	iterator().forEachRemaining(action);
-	 * }</pre>
-	 *
-	 * @param action The action to be performed for each element
-	 * @throws NullPointerException if the specified action is null
-	 * @see Iterable#forEach(Consumer)
-	 */
-	default void forEach(BooleanConsumer action) {
-		Objects.requireNonNull(action);
-		iterator().forEachRemaining(action);
-	}
-	
-	/** {@inheritDoc}
-	* <p>This default implementation delegates to the corresponding type-specific function.
-	* @deprecated Please use the corresponding type-specific function instead. 
-	*/
-	@Deprecated
-	@Override
-	default void forEach(Consumer<? super Boolean> action) {
-		Objects.requireNonNull(action);
-		iterator().forEachRemaining(action);
-	}
-	
-	/**
-	 * A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
-	 * @param action The action to be performed for each element
-	 * @throws java.lang.NullPointerException if the specified action is null
-	 */
-	public default void forEachIndexed(IntBooleanConsumer action) {
-		Objects.requireNonNull(action);
-		int index = 0;
-		for(BooleanIterator iter = iterator();iter.hasNext();action.accept(index++, iter.nextBoolean()));
-	}
-	
-	/**
-	 * Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
-	 * @param input the object that should be included
-	 * @param action The action to be performed for each element
-	 * @param <E> the generic type of the Object
-	 * @throws java.lang.NullPointerException if the specified action is null
-	 */
-	default <E> void forEach(E input, ObjectBooleanConsumer<E> action) {
-		Objects.requireNonNull(action);
-		iterator().forEachRemaining(input, action);
-	}
-	
-	/**
-	 * A Type Specific Type Splititerator to reduce boxing/unboxing
-	 * @return type specific splititerator
-	 */
-	@Override
-	default BooleanSplititerator spliterator() { return BooleanSplititerators.createUnknownSplititerator(iterator(), 0); }
-	
-	/**
-	 * Creates a Async Builder for moving work of the thread.
-	 * It is not designed to split the work to multithreaded work, so using this keep it singlethreaded, but it allows to be moved to another thread.
-	 * @see BooleanAsyncBuilder
-	 * @return a AsyncBuilder
-	 */
-	default BooleanAsyncBuilder asAsync() {
-		return new BooleanAsyncBuilder(this);
-	}
-
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	 * @param mapper the mapping function
-	 * @param <E> The return type.
-	 * @return a new Iterable that returns the desired result
-	 */
-	default <E> ObjectIterable<E> map(BooleanFunction<E> mapper) {
-		return BooleanIterables.map(this, mapper);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	 * @param mapper the flatMapping function
-	 * @param <V> The return type supplier.
-	 * @param <E> The return type.
-	 * @return a new Iterable that returns the desired result
-	 * @note does not support toBooleanArray optimizations.
-	 */
-	default <E, V extends Iterable<E>> ObjectIterable<E> flatMap(BooleanFunction<V> mapper) {
-		return BooleanIterables.flatMap(this, mapper);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	 * @param mapper the flatMapping function
-	 * @param <E> The return type.
-	 * @return a new Iterable that returns the desired result
-	 * @note does not support toBooleanArray optimizations.
-	 */
-	default <E> ObjectIterable<E> arrayflatMap(BooleanFunction<E[]> mapper) {
-		return BooleanIterables.arrayFlatMap(this, mapper);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to filter out unwanted elements
-	 * @param filter the elements that should be kept.
-	 * @return a Iterable that filtered out all unwanted elements
-	 * @note does not support toBooleanArray optimizations.
-	 */
-	default BooleanIterable filter(BooleanPredicate filter) {
-		return BooleanIterables.filter(this, filter);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to filter out duplicated elements
-	 * @return a Iterable that filtered out all duplicated elements
-	 * @note does not support toBooleanArray optimizations.
-	 */
-	default BooleanIterable distinct() {
-		return BooleanIterables.distinct(this);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to repeat elements a desired amount of times
-	 * @param repeats how many times the elements should be repeated
-	 * @return a Iterable that is repeating multiple times
-	 */
-	default BooleanIterable repeat(int repeats) {
-		return BooleanIterables.repeat(this, repeats);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to limit the amount of elements
-	 * @param limit the amount of elements it should be limited to
-	 * @return a Iterable that is limited in length
-	 */
-	default BooleanIterable limit(long limit) {
-		return BooleanIterables.limit(this, limit);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to sort the elements
-	 * @param sorter that sorts the elements.
-	 * @return a Iterable that is sorted
-	 */
-	default BooleanIterable sorted(BooleanComparator sorter) {
-		return BooleanIterables.sorted(this, sorter);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to preview elements before they are iterated through
-	 * @param action the action that should be applied
-	 * @return a Peeked Iterable
-	 */
-	default BooleanIterable peek(BooleanConsumer action) {
-		return BooleanIterables.peek(this, action);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to collect all elements
-	 * @param collection that the elements should be inserted to
-	 * @param <E> the collection type
-	 * @return the input with the desired elements
-	 */
-	default <E extends BooleanCollection> E pour(E collection) {
-		BooleanIterators.pour(iterator(), collection);
-		return collection;
-	}
-	
-	/**
-	 * A Helper function that reduces the usage of streams and allows to collect all elements as a ArrayList
-	 * @return a new ArrayList of all elements
-	 */
-	default BooleanList pourAsList() {
-		return pour(new BooleanArrayList());
-	}
-	
-	/**
-	 * A Helper function that reduces the usage of streams and allows to collect all elements as a Array
-	 * @return a new Array of all elements
-	 */
-	default boolean[] toBooleanArray() {
-		ISizeProvider prov = ISizeProvider.of(this);
-		if(prov != null) {
-			int size = prov.size();
-			if(size >= 0) {
-				boolean[] array = new boolean[size];
-				BooleanIterators.unwrap(array, iterator());
-				return array;
-			}
-		}
-		return BooleanArrays.pour(iterator());
-	}
-	
-	/**
-	 * Helper function to reduce stream usage that allows to filter for any matches.
-	 * @param filter that should be applied
-	 * @return true if any matches were found
-	 */
-	default boolean matchesAny(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(filter.test(iter.nextBoolean())) return true;
-		}
-		return false;
-	}
-	
-	/**
-	 * Helper function to reduce stream usage that allows to filter for no matches.
-	 * @param filter that should be applied
-	 * @return true if no matches were found
-	 */
-	default boolean matchesNone(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(filter.test(iter.nextBoolean())) return false;
-		}
-		return true;
-	}
-	
-	/**
-	 * Helper function to reduce stream usage that allows to filter for all matches.
-	 * @param filter that should be applied
-	 * @return true if all matches.
-	 */
-	default boolean matchesAll(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(!filter.test(iter.nextBoolean())) return false;
-		}
-		return true;
-	}
-	
-	/**
-	 * Helper function to reduce stream usage that allows to filter for the first match.
-	 * @param filter that should be applied
-	 * @return the found value or the null equivalent variant.
-	 */
-	default OptionalBoolean findFirst(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			boolean entry = iter.nextBoolean();
-			if(filter.test(entry)) return OptionalBoolean.of(entry);
-		}
-		return OptionalBoolean.empty();
-	}
-	
-	/**
-	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
-     * elements of this Iterable
-	 * @param operator the operation that should be applied
-	 * @param identity the start value
-	 * @return the reduction result, returns identity if nothing was found
-	 */
-	default boolean reduce(boolean identity, BooleanBooleanUnaryOperator operator) {
-		Objects.requireNonNull(operator);
-		boolean state = identity;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			state = operator.applyAsBoolean(state, iter.nextBoolean());
-		}
-		return state;
-	}
-	
-	/**
-	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
-	 * elements of this Iterable
-	 * @param operator the operation that should be applied
-	 * @return the reduction result, returns null value if nothing was found
-	 */
-	default OptionalBoolean reduce(BooleanBooleanUnaryOperator operator) {
-		Objects.requireNonNull(operator);
-		boolean state = false;
-		boolean empty = true;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(empty) {
-				empty = false;
-				state = iter.nextBoolean();
-				continue;
-			}
-			state = operator.applyAsBoolean(state, iter.nextBoolean());
-		}
-		return empty ? OptionalBoolean.empty() : OptionalBoolean.of(state);
-	}	
-	
-	/**
-	 * Helper function to reduce stream usage that allows to count the valid elements.
-	 * @param filter that should be applied
-	 * @return the amount of Valid Elements
-	 */
-	default int count(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		int result = 0;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(filter.test(iter.nextBoolean())) result++;
-		}
-		return result;
-	}
-}

src/main/java/speiger/src/collections/booleans/collections/BooleanIterator.java

@@ -1,88 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Iterator;
-import java.util.Objects;
-import java.util.function.Consumer;
-
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-
-import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer;
-
-/**
- * A Type-Specific {@link Iterator} that reduces (un)boxing
- */
-public interface BooleanIterator extends Iterator<Boolean>
-{
-	/**
- 	* Returns the next element in the iteration.
- 	*
- 	* @return the next element in the iteration
- 	* @throws java.util.NoSuchElementException if the iteration has no more elements
- 	* @see Iterator#next()
- 	*/
-	public boolean nextBoolean();
-	
-	/** {@inheritDoc}
-	* <p>This default implementation delegates to the corresponding type-specific function.
-	* @deprecated Please use the corresponding type-specific function instead. 
-	*/
-	@Override
-	@Deprecated
-	public default Boolean next() { return Boolean.valueOf(nextBoolean()); }
-	
-	/**
-	 * Performs the given action for each remaining element until all elements
-	 * have been processed or the action throws an exception.  Actions are
-	 * performed in the order of iteration, if that order is specified.
-	 * Exceptions thrown by the action are relayed to the caller.
-	 *
-	 * @implSpec
-	 * <p>The default implementation behaves as if:
-	 * <pre>{@code
-	 *	while (hasNext()) action.accept(nextBoolean());
-	 * }</pre>
-	 *
-	 * @param action The action to be performed for each element
-	 * @throws java.lang.NullPointerException if the specified action is null
-	 * @see Iterator#forEachRemaining(Consumer)
-	 */
-	public default void forEachRemaining(BooleanConsumer action) {
-		Objects.requireNonNull(action);
-		while(hasNext()) { action.accept(nextBoolean()); }
-	}
-	
-	/** {@inheritDoc}
- 	* <p>This default implementation delegates to the corresponding type-specific function.
- 	* @deprecated Please use the corresponding type-specific function instead. 
- 	*/
-	@Deprecated
-	@Override
-	default void forEachRemaining(Consumer<? super Boolean> action) {
-		Objects.requireNonNull(action);
-		forEachRemaining(action::accept);
-	}
-	
-	/**
-	 * Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
-	 * @param input the object that should be included
-	 * @param action The action to be performed for each element
-	 * @param <E> the generic type of the Object
-	 * @throws java.lang.NullPointerException if the specified action is null
-	 */
-	default <E> void forEachRemaining(E input, ObjectBooleanConsumer<E> action) {
-		Objects.requireNonNull(action);
-		while(hasNext()) { action.accept(input, nextBoolean()); }
-	}
-	
-	/**
-	 * Skips the Given amount of elements if possible. A Optimization function to skip elements faster if the implementation allows it.
-	 * @param amount the amount of elements that should be skipped
-	 * @return the amount of elements that were skipped
-	 */
-	default int skip(int amount) {
-		if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-		int i = 0;
-		for(;i<amount && hasNext();nextBoolean(), i++);
-		return i;
-	}
-}

src/main/java/speiger/src/collections/booleans/collections/BooleanOrderedCollection.java

@@ -1,40 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-public interface BooleanOrderedCollection extends BooleanCollection {
-	
-	BooleanOrderedCollection reversed();
-	
-	/**
-	 * A method to add an element to the start of a collection
-	 * @param e that should be added at the start.
-	 */
-	public void addFirst(boolean e);
-	
-	/**
-	 * A method to add an element to the end of a collection
-	 * @param e that should be added at the end.
-	 */
-	public void addLast(boolean e);
-	
-	/**
-	 * A method to get the first element in the collection
-	 * @return first element in the collection
-	 */
-	public boolean getFirstBoolean();
-	/**
-	 * A method to get and remove the first element in the collection
-	 * @return first element in the collection
-	 */
-	public boolean removeFirstBoolean();
-	/**
-	 * A method to get the last element in the collection
-	 * @return last element in the collection
-	 */
-	public boolean getLastBoolean();
-	/**
-	 * A method to get and remove the last element in the collection
-	 * @return last element in the collection
-	 */
-	public boolean removeLastBoolean();
-	
-}

src/main/java/speiger/src/collections/booleans/collections/BooleanSplititerator.java

@@ -1,19 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Spliterator.OfPrimitive;
-import java.util.function.Consumer;
-
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-
-/**
- * A Type Specific Split-Iterator that reduces boxing/unboxing
- * It fills the gaps of the java and uses this collection interfaces
- */
-public interface BooleanSplititerator extends OfPrimitive<Boolean, BooleanConsumer, BooleanSplititerator>, BooleanIterator
-{
-	@Override
-	default void forEachRemaining(BooleanConsumer action) { BooleanIterator.super.forEachRemaining(action); }
-	@Override
-	@Deprecated
-	default void forEachRemaining(Consumer<? super Boolean> action) { BooleanIterator.super.forEachRemaining(action); }
-}

src/main/java/speiger/src/collections/booleans/collections/BooleanStack.java

@@ -1,85 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.NoSuchElementException;
-
-import speiger.src.collections.utils.Stack;
-
-/**
- * A Type-Specific {@link Stack} that reduces (un)boxing
- */
-public interface BooleanStack
-{
-	/**
-	 * Inserts a given Object on top of the stack
-	 * @param e the Object to insert
-	 * @see Stack#push(Object)
-	 */
-	public void push(boolean e);
-	
-	/**
-	 * Helper function that pushes the top element on top of the stack again.
-	 * @throws NoSuchElementException if the stack is empty
-	 */
-	public default void pushTop() {
-		push(top());
-	}
-	
-	/**
-	 * Removes the Object on top of the stack.
-	 * @return the element that is on top of the stack
-	 * @throws ArrayIndexOutOfBoundsException if the stack is empty
-	 * @see Stack#pop()
-	 */
-	public boolean pop();
-	
-	/**
-	 * Provides the Object on top of the stack
-	 * @return the element that is on top of the stack
-	 * @throws ArrayIndexOutOfBoundsException if the stack is empty
- 	 * @see Stack#top()
-	 */
-	public default boolean top() {
-		return peek(0);
-	}
-	
-	/**
-	 * Provides the Selected Object from the stack.
-	 * Top to bottom
-	 * @param index of the element that should be provided
-	 * @return the element that was requested
- 	 * @throws ArrayIndexOutOfBoundsException if the index is out of bounds
- 	 * @see Stack#peek(int)
-	 */
-	public boolean peek(int index);
-	
-	/**
-	 * Clears the stack
-	 */
-	public void clear();
-	
-	/**
-	 * Provides the amount of elements currently in the stack
-	 * @return amount of elements in the list
-	 */
-	public int size();
-	
-	/**
-	 * @return if the stack is empty
-	 */
-	public default boolean isEmpty() {
-		return size() == 0;
-	}
-	
-	/**
-	 * A method to drop the contents of the Stack without clearing the stack
-	 * @return the contents of the stack into a seperate array.
-	 */
-	public default boolean[] toBooleanArray() { return toBooleanArray(new boolean[size()]); }
-	/**
-	 * A method to drop the contents of the Stack without clearing the stack
-	 * @param input where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
-	 * @return the contents of the stack into a seperate array.
-	 * @note if the Type is generic then a Object Array is created instead of a Type Array
-	 */
-	public boolean[] toBooleanArray(boolean[] input);
-}