Fixed Classification

Fixing Jitpack Publishing
Trying switching Jitpack Java version.
2022-04-14 09:34:16 +02:00 · 2022-04-14 09:24:13 +02:00 · 2022-04-14 09:19:27 +02:00 · 2022-04-14 09:13:53 +02:00 · 2022-04-14 09:12:03 +02:00 · 2022-04-14 07:56:39 +02:00
50 changed files with 5808 additions and 1698 deletions
@@ -0,0 +1,38 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: Latest Build
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        jdk: [8, 11, 14, 16, 17]
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK ${{ matrix.jdk }}
+      uses: actions/setup-java@v1
+      with:
+        java-version: ${{ matrix.jdk }}
+    - name: Validate Gradle wrapper
+      uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
+    - name: Make gradlew executable
+      run: chmod +x ./gradlew
+    - name: Generate SourceCode with Gradle
+      run: ./gradlew generateGithubSource
+    - name: Build with Gradle
+      run: ./gradlew build
@@ -1,7 +1,6 @@
 # ---> Gradle
 .gradle
 /build/
-gradle.properties

 # Ignore Gradle GUI config
 gradle-app.setting
@@ -1,5 +1,16 @@
 # Changelog of versions

+### Version 0.6.0
+- Added: addOrGet for sets.
+- Added: Async API which allows to easily execute Iterables/Collections offthread without the complexity.
+- Added: CopyOnWriteArrayList and tests for it
+- Added: Support up to Java17.
+- Added: Build System now adds module-info if the Running JVM is 9 or higher
+- Added: ArrayList.of(Class, size) that allows you to allocate a size right at the creation of the List without having to create a wrapper array.
+- Added: A ConcurrentHashMap implementation.
+- Fixed: containsValue in the HashMap wouldn't check the nullKey
+- Removed: Deprecated functions from SortedMaps/Sets
+
 ### Version 0.5.3
 - Added: OrderedMap/Set
 - Added: Deprecation to Functions that are specific to Ordered interfaces in the SortedMap/Set
@@ -1,3 +1,5 @@
+![build](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_validator.yml/badge.svg)
+
 # Primitive-Collections

 This is a Simple Primitive Collections Library i started as a hobby Project.     
@@ -5,11 +7,12 @@ It is based on Java's Collection Library and FastUtil.
 But its focus is a different one.     

 ## Main Features:      
- ArrayLists / LinkedLists
+- ArrayLists / LinkedLists / CopyOnWriteLists
 - HashSets/Maps (Linked & HashControl)
 - TreeSets/Maps (RB & AVL)
 - EnumMaps
 - Immutable Maps/Lists/Sets
+- ConcurrentHashMaps
 - Priority Queues
 - Streams & Functional Queries
 - SplitIterators
@@ -18,7 +21,7 @@ But its focus is a different one.
 - Unary/Functions
 - Suppliers
 - Bi/Consumers
-
+- AsyncBuilders

 ## Current Level of Stability
 Since this is a relatively new Library, stability was not perfect and some areas are not perfect yet.     
@@ -93,13 +96,14 @@ repositories {
    }
 }
 dependencies {
-	compile 'de.speiger:Primitive-Collections:0.5.3'
+	compile 'de.speiger:Primitive-Collections:0.6.0'
 }
 ```
 Direct:

 | Version 	| Jar                                                                                                                          	| Sources                                                                                                                              	| Java Doc                                                                                                                             	|
 |---------	|------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|
+| 0.6.0   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.0/Primitive-Collections-0.6.0.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.0/Primitive-Collections-0.6.0-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.0/Primitive-Collections-0.6.0-javadoc.jar) 	|
 | 0.5.3   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3-javadoc.jar) 	|
 | 0.5.2   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2-javadoc.jar) 	|
 | 0.5.1   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1-javadoc.jar) 	|
@@ -8,7 +8,7 @@ tasks.withType(JavaCompile) {

 apply plugin: 'java'
 apply plugin: 'eclipse'
-apply plugin: 'maven'
+apply plugin: 'maven-publish'

 repositories {
    mavenCentral()
@@ -18,9 +18,11 @@ repositories {
 }

 archivesBaseName = 'Primitive Collections'
-version = '0.5.3';
+version = '0.6.0';

-sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8'
+sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaVersion.current();
+
+System.out.println("Java Version: "+compileJava.sourceCompatibility)

 javadoc {
    options.tags = [ "implSpec", "note" ] 
@@ -42,8 +44,7 @@ configurations {
 }

 dependencies {
-	builderCompile 'de.speiger:Simple-Code-Generator:1.0.5'
-	runtimeOnly 'de.speiger:Simple-Code-Generator:1.0.5'
+	builderImplementation 'de.speiger:Simple-Code-Generator:1.0.7'
    testImplementation 'junit:junit:4.12'
    testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
 }
@@ -55,6 +56,14 @@ task generateSource(type: JavaExec) {
 	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
 }

+task generateGithubSource(type: JavaExec) {
+	group = 'internal'
+	description = 'Builds the sourcecode for Github Actions'
+ 	classpath = sourceSets.builder.runtimeClasspath
+ 	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
+ 	args = ['false', 'true']
+}
+
 task forceGenerateSource(type: JavaExec) {
 	group = 'internal'
 	description = 'Builds the sourcecode forceful'
@@ -86,19 +95,23 @@ test {
    useJUnit()
 }

-uploadArchives {
-	repositories.mavenDeployer {
-		repository(url: 'https://maven.speiger.com/repository/main') {
-			authentication(userName: project.properties.mavenUser, password: project.properties.mavenPassword)
-		}
-		snapshotRepository(url: 'https://maven.speiger.com/repository/main') {
-			authentication(userName: project.properties.mavenUser, password: project.properties.mavenPassword)
-		}
-		pom {
-			version = project.version
-			artifactId = project.archivesBaseName.replace(" ", "-")
-			groupId = 'de.speiger'
-			project {
+publishing {
+	Properties props = new Properties()
+	if(file("$buildDir/credentials.properties").exists()) {
+		props.load(new FileInputStream("$buildDir/credentials.properties"))
+	}
+	publications {
+		mavenJava(MavenPublication) {
+			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
+				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'
@@ -109,9 +122,24 @@ uploadArchives {
 					developer {
 						id = 'speiger'
 						name = 'Speiger'
-						email = 'speiger@gmx.net'
 					}
 				}
+				scm {
+					url = 'https://github.com/Speiger/Primitive-Collections'
+				}
+				issueManagement {
+					system = 'github'
+					url = 'https://github.com/Speiger/Primitive-Collections/issues'
+				}
+			}
+		}
+	}
+	repositories {
+		maven {
+			url version.endsWith('SNAPSHOT') ? "https://maven.speiger.com/repository/debug" : "https://maven.speiger.com/repository/main"
+			credentials(PasswordCredentials) {
+				username props.mavenUser
+				password props.mavenPassword
 			}
 		}
 	}
@@ -0,0 +1 @@
+org.gradle.jvmargs=-Xmx3G
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -0,0 +1,7 @@
+jdk:
+   - openjdk9
+install:
+   - chmod +x ./gradlew
+   - ./gradlew generateGithubSource
+   - ./gradlew build publishToMavenLocal
+   
@@ -158,6 +158,8 @@ public class GlobalVariables
 		
 		//Final Classes
 		addClassMapper("ARRAY_LIST", "ArrayList");
+		addAbstractMapper("COPY_ON_WRITE_LIST", "CopyOnWrite%sArrayList");
+		addClassMapper("ASYNC_BUILDER", "AsyncBuilder");
 		addClassMapper("LINKED_LIST", "LinkedList");
 		addAbstractMapper("IMMUTABLE_LIST", "Immutable%sList");
 		addClassMapper("ARRAY_FIFO_QUEUE", "ArrayFIFOQueue");
@@ -172,6 +174,7 @@ public class GlobalVariables
 		addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
 		addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
 		addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
+		addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
 		addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
 		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
 		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
@@ -191,6 +194,7 @@ public class GlobalVariables
 		addAbstractMapper("ABSTRACT_LIST", "Abstract%sList");
 		addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
 		addClassMapper("SUB_LIST", "SubList");
+		addAbstractMapper("BASE_TASK", "Base%sTask");
 		
 		//Helper Classes
 		addClassMapper("LISTS", "Lists");
@@ -220,6 +224,7 @@ public class GlobalVariables
 		addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
 		addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
 		addBiClassMapper("SORTED_MAP", "SortedMap", "2");
+		addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
 		addBiClassMapper("MAP", "Map", "2");
 		addClassMapper("NAVIGABLE_SET", "NavigableSet");
 		addBiClassMapper("PAIR", "Pair", "");
@@ -233,6 +238,7 @@ public class GlobalVariables
 		addClassMapper("STACK", "Stack");
 		addClassMapper("SUPPLIER", "Supplier");
 		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
+		addClassMapper("TASK", "Task");
 		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");
 		if(type.isObject())
 		{
@@ -1,6 +1,8 @@
 package speiger.src.builder;

+import java.io.BufferedWriter;
 import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -10,7 +12,9 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.StringJoiner;
 import java.util.function.Consumer;
+import java.util.stream.Stream;

 import speiger.src.builder.processor.TemplateProcess;
 import speiger.src.builder.processor.TemplateProcessor;
@@ -29,12 +33,22 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	
 	public PrimitiveCollectionsBuilder()
 	{
-		super(Paths.get("src/builder/resources/speiger/assets/collections/templates/"), Paths.get("src/main/java/speiger/src/collections/"), Paths.get("src/builder/resources/speiger/assets/collections/"));
+		this(false);
+	}
+	
+	public PrimitiveCollectionsBuilder(boolean silencedSuccess)
+	{
+		super(silencedSuccess, Paths.get("src/builder/resources/speiger/assets/collections/templates/"), Paths.get("src/main/java/speiger/src/collections/"), Paths.get("src/builder/resources/speiger/assets/collections/"));
 	}
 	
 	public PrimitiveCollectionsBuilder(Path sourceFolder, Path outputFolder, Path dataFolder)
 	{
-		super(sourceFolder, outputFolder, dataFolder);
+		this(false, sourceFolder, outputFolder, dataFolder);
+	}
+	
+	public PrimitiveCollectionsBuilder(boolean silencedSuccess, Path sourceFolder, Path outputFolder, Path dataFolder)
+	{
+		super(silencedSuccess, sourceFolder, outputFolder, dataFolder);
 	}
 	
 	@Override
@@ -55,6 +69,23 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		return false;
 	}
 	
+	@Override
+	protected void afterFinish()
+	{
+		if(getVersion() > 8) 
+		{
+			Path basePath = Paths.get("src/main/java");
+			try(BufferedWriter writer = Files.newBufferedWriter(basePath.resolve("module-info.java")))
+			{
+				writer.write(getModuleInfo(basePath));
+			}
+			catch(Exception e)
+			{
+				e.printStackTrace();
+			}
+		}
+	}
+	
 	@Override
 	protected void init()
 	{
@@ -73,7 +104,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		biRequired.put("Pair", "");
 		biRequired.put("MutablePair", "");
 		biRequired.put("ImmutablePair", "");
-		addBiClass("Function", "Maps", "Map", "SortedMap", "OrderedMap", "NavigableMap", "AbstractMap", "ImmutableOpenHashMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
+		addBiClass("Function", "Maps", "Map", "SortedMap", "OrderedMap", "NavigableMap", "ConcurrentMap", "AbstractMap", "ConcurrentOpenHashMap", "ImmutableOpenHashMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
 		nameRemapper.put("BiConsumer", "%sConsumer");
 		nameRemapper.put("IArray", "I%sArray");
 		nameRemapper.put("AbstractMap", "Abstract%sMap");
@@ -84,12 +115,13 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		nameRemapper.put("EnumMap", "Enum2%sMap");
 		nameRemapper.put("LinkedEnumMap", "LinkedEnum2%sMap");
 		nameRemapper.put("ImmutableList", "Immutable%sList");
+		nameRemapper.put("CopyOnWriteList", "CopyOnWrite%sArrayList");
 		nameRemapper.put("ImmutableOpenHashSet", "Immutable%sOpenHashSet");
 		nameRemapper.put("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
 		
 		addBlockage(ClassType.OBJECT, "Consumer", "Comparator", "Stack");
 		addBlockage(ClassType.BOOLEAN, "ArraySet", "AVLTreeSet", "RBTreeSet", "SortedSet", "OrderedSet", "NavigableSet", "OpenHashSet", "OpenCustomHashSet", "LinkedOpenHashSet", "LinkedOpenCustomHashSet");
-		addBlockage(ClassType.BOOLEAN, "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "OrderedMap", "NavigableMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
+		addBlockage(ClassType.BOOLEAN, "ConcurrentOpenHashMap", "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "OrderedMap", "NavigableMap", "ConcurrentMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
 	}
 	
 	protected void create(ClassType mainType, ClassType subType) 
@@ -151,6 +183,55 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		return variables;
 	}
 	
+	private String getModuleInfo(Path basePath) {
+		StringJoiner joiner = new StringJoiner("\n", "", "\n");
+		try(Stream<Path> stream = Files.walk(getOutputFolder()))
+		{
+			stream.filter(Files::isDirectory)
+					.filter(this::containsFiles)
+					.map(basePath::relativize)
+					.map(Path::toString)
+					.map(this::sanitize)
+					.forEach(T -> joiner.add("\texports "+T+";"));
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+			throw new RuntimeException(e);
+		}
+		StringBuilder builder = new StringBuilder();
+		builder.append("/** @author Speiger */\n");
+		builder.append("module ").append(sanitize(basePath.relativize(getOutputFolder()).toString())).append(" {\n");
+		builder.append(joiner.toString()).append("}");	
+		return builder.toString();
+	}
+	
+	private String sanitize(String input)
+	{
+		return input.replace("\\", ".").replace("/", ".");
+	}
+	
+	private boolean containsFiles(Path path) 
+	{
+		try(Stream<Path> stream = Files.walk(path, 1))
+		{
+			return stream.filter(Files::isRegularFile).findFirst().isPresent();
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+		return false;
+	}
+	
+	private int getVersion() 
+	{
+		String version = System.getProperty("java.version");
+		if(version.startsWith("1.")) return Integer.parseInt(version.substring(2, 3));
+		int dot = version.indexOf(".");
+		return Integer.parseInt(dot != -1 ? version.substring(0, dot) : version);
+	}
+	
 	public static void main(String...args)
 	{
 		try
@@ -159,10 +240,14 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	            new PrimitiveCollectionsBuilder().process(false);
 	        } else if(args.length == 1) {
 	            new PrimitiveCollectionsBuilder().process(Boolean.parseBoolean(args[0]));
+	        } else if(args.length == 2) {
+	            new PrimitiveCollectionsBuilder(Boolean.parseBoolean(args[1])).process(Boolean.parseBoolean(args[0]));
 	        } else if(args.length == 3) {
 	            new PrimitiveCollectionsBuilder(Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(false);
 	        } else if(args.length == 4) {
-	            new PrimitiveCollectionsBuilder(Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
+	            new PrimitiveCollectionsBuilder(false, Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
+	        } else if(args.length == 4) {
+	            new PrimitiveCollectionsBuilder(Boolean.parseBoolean(args[4]), Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
 	        } else {
 	            System.out.println("Invalid argument count passed in");
 	            System.exit(1);
@@ -7,7 +7,6 @@ import java.util.AbstractCollection;
 import java.util.function.Consumer;
 #endif

-import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -100,7 +99,6 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 	 * 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
-	 * @deprecated if this is a primitive collection
 	 * @throws java.lang.NullPointerException if the collection is null
 	 */
 	@Override
@@ -14,13 +14,13 @@ import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
-import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST;
 import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
 #if !TYPE_BOOLEAN
 import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
 #endif
+import speiger.src.collections.PACKAGE.utils.ASYNC_BUILDER;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 import speiger.src.collections.PACKAGE.utils.ITERABLES;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -89,6 +89,16 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	@Override
 	default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.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 ASYNC_BUILDER
+	 * @return a AsyncBuilder
+	 */
+	default ASYNC_BUILDER KEY_GENERIC_TYPE asAsync() {
+		return new ASYNC_BUILDERBRACES(this);
+	}
+
 	/**
 	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
 	 * @param mapper the mapping function
@@ -50,6 +50,10 @@ public interface COMPARATOR extends Comparator<CLASS_TYPE>
 	{
 		COMPARATOR original;
 		
+		/**
+		 * default constructor
+		 * @param original that is going to be reversed
+		 */
 		public Reversed(COMPARATOR original) {
 			this.original = original;
 		}
@@ -0,0 +1,92 @@
+package speiger.src.collections.PACKAGE.functions;
+
+import java.util.concurrent.RunnableFuture;
+#if !TYPE_OBJECT
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+#endif
+
+/**
+ * 
+ * A Type Specific Task interface that allows you to keep track of the task that is currently running.<br>
+ * It extends Runnable future and supports said functions but also provides quality of life functions like:<br>
+ * 
+ * - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed.
+ * - pause/resume: which allows to pause/resume the task at any moment, making it easier to create thread-safe actions.
+ * @Type(T)
+ */
+public interface TASK KEY_GENERIC_TYPE extends RunnableFuture<CLASS_TYPE> {
+	/**
+	 * Helper function to detect if the task is currently paused.
+	 * @return true if paused
+	 */
+	public boolean isPaused();
+	
+	/**
+	 * Pauses the task, which lets the thread finish without completing the task.
+	 * Tasks are written in the way where they can pause without any issues.
+	 * This won't be instant, as this function is applied asynchronous and doesn't check if the thread paused.
+	 * So make sure it had the time to pause.
+	 */
+	public void pause();
+	
+	/**
+	 * Pauses the task, which lets the thread finish without completing the task.
+	 * Tasks are written in the way where they can pause without any issues.
+	 * This won't be instant, as this function is applied asynchronous.
+	 * It will await the pausing of the task.
+	 */
+	public void awaitPausing();
+	
+	/**
+	 * Continues the task if it wasn't already completed.
+	 * This is done by resubmitting the task to the executor provided.
+	 */
+	public void resume();
+	
+	/**
+	 * Quality of life function that allows to detect if no cancellation/exception was applied to this task and it completed on its own.
+	 * @return true if it was properly completed
+	 */
+	public boolean isSuccessful();
+	
+#if !TYPE_OBJECT
+	/**
+	 * A Type Specific get method that allows to reduce (un)boxing of primtives.
+	 * 
+	 * Waits if necessary for the computation to complete, and then
+	 * retrieves its result.
+	 *
+	 * @return the computed result as primitive
+	 * @throws CancellationException if the computation was cancelled
+	 * @throws ExecutionException if the computation threw an exception
+	 * @throws InterruptedException if the current thread was interrupted
+	 * while waiting
+	 */
+	public KEY_TYPE GET_KEY() throws InterruptedException, ExecutionException;
+
+	/**
+	 * Waits if necessary for at most the given time for the computation
+	 * to complete, and then retrieves its result, if available.
+	 *
+	 * @param timeout the maximum time to wait
+	 * @param unit the time unit of the timeout argument
+	 * @return the computed result as primitive
+	 * @throws CancellationException if the computation was cancelled
+	 * @throws ExecutionException if the computation threw an exception
+	 * @throws InterruptedException if the current thread was interrupted while waiting
+	 * @throws TimeoutException if the wait timed out
+	 */
+	public KEY_TYPE GET_KEY(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
+	
+	@Override
+	@Deprecated
+	public default CLASS_TYPE get() throws InterruptedException, ExecutionException { return KEY_TO_OBJ(GET_KEY()); }
+	
+	@Override
+	@Deprecated
+	public default CLASS_TYPE get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return KEY_TO_OBJ(GET_KEY(timeout, unit)); }
+#endif
+}
@@ -75,7 +75,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	 * The IndexOf implementation iterates over all elements and compares them to the search value.
 	 * @param o the value that the index is searched for.
 	 * @return index of the value that was searched for. -1 if not found
-	 * @deprecated it is highly suggested not to use this with Primitives because of boxing. But it is still supported because of ObjectComparason that are custom objects and allow to find the contents.
+	 * @note it is highly suggested not to use this with Primitives because of boxing. But it is still supported because of ObjectComparason that are custom objects and allow to find the contents.
 	 */
 	@Override
 	@Primitive
@@ -103,7 +103,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	 * The lastIndexOf implementation iterates over all elements and compares them to the search value.
 	 * @param o the value that the index is searched for.
 	 * @return the last index of the value that was searched for. -1 if not found
-	 * @deprecated it is highly suggested not to use this with Primitives because of boxing. But it is still supported because of ObjectComparason that are custom objects and allow to find the contents.
+	 * @note it is highly suggested not to use this with Primitives because of boxing. But it is still supported because of ObjectComparason that are custom objects and allow to find the contents.
 	 */
 	@Override
 	@Primitive
@@ -188,12 +188,25 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return list;
 	}

+	/**
+	 * Creates a new ArrayList with a EmptyObject array of the Type requested
+	 * @param c the type of the array
+	 * @param size the initial size of the backing array
+	 * @Type(T)
+	 * @return a typed List
+	 */
+	public static GENERIC_KEY_BRACES ARRAY_LIST KEY_GENERIC_TYPE of(Class<KEY_TYPE> c, int size) {
+		ARRAY_LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		list.data = (KEY_TYPE[])ObjectArrays.newArray(c, size);
+		return list;
+	}
+	
 #endif
 	/**
 	 * Appends the specified element to the end of this list.
 	 *
 	 * @param e element to be appended to this list
-	 * @return <tt>true</tt> (as specified by {@link Collection#add})
+	 * @return true (as specified by {@link Collection#add})
 	 */
 	@Override
 	public boolean add(KEY_TYPE e) {
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.maps.impl.customHash;

 import java.util.Arrays;
-import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
@@ -10,7 +9,6 @@ import java.util.Objects;

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #endif
@@ -22,9 +20,8 @@ import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.PACKAGE.utils.STRATEGY;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
@@ -60,7 +57,6 @@ import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOpera
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectSortedSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 #endif
 import speiger.src.collections.utils.HashUtil;
@@ -72,7 +68,7 @@ import speiger.src.collections.utils.HashUtil;
 * @Type(T)
 * @ValueType(V) 
 */
-public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;
@@ -364,20 +360,6 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		return map;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		return null;
-	}
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public KEY_TYPE FIRST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
@@ -621,7 +603,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		values = newValues;
 	}
 	
-	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements SORTED_MAP.FastSortedSet KEY_VALUE_GENERIC_TYPE {
+	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -861,20 +843,9 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		public void clear() {
 			LINKED_CUSTOM_HASH_MAP.this.clear();
 		}
-		
-		@Override
-		public Comparator<MAP.Entry KEY_VALUE_GENERIC_TYPE> comparator() {
-			return null;
-		}
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> subSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement, MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> headSet(MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> tailSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
-	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
 #if TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -1093,18 +1064,6 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			}
 			return result;
 		}
-		
-		@Override
-		public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-		
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
 	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
@@ -316,6 +316,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 #if !VALUE_OBJECT
 	@Override
 	public boolean containsValue(VALUE_TYPE value) {
+		if(containsNull && VALUE_EQUALS(values[nullIndex], value)) return true;
 		for(int i = nullIndex;i >= 0;i--)
 			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && VALUE_EQUALS(values[i], value)) return true;
 		return false;
@@ -325,7 +326,12 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	@Override
 	@ValuePrimitive
 	public boolean containsValue(Object value) {
-		for(int i = nullIndex;i >= 0;i--)
+#if VALUE_OBJECT
+		if(containsNull && VALUE_EQUALS(values[nullIndex], value)) return true;
+#else
+		if(containsNull && ((value == null && values[nullIndex] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[nullIndex], value))) return true;
+#endif
+		for(int i = nullIndex-1;i >= 0;i--)
 #if VALUE_OBJECT
 			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && EQUALS_VALUE_TYPE(values[i], value)) return true;
 #else
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.maps.impl.hash;

 import java.util.Arrays;
-import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
@@ -10,7 +9,6 @@ import java.util.Objects;

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #endif
@@ -21,10 +19,9 @@ import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -59,7 +56,6 @@ import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOpera
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectSortedSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 #endif
 import speiger.src.collections.utils.HashUtil;
@@ -71,7 +67,7 @@ import speiger.src.collections.utils.HashUtil;
 * @Type(T)
 * @ValueType(V)
 */
-public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;
@@ -368,20 +364,6 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		return map;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		return null;
-	}
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public KEY_TYPE FIRST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
@@ -625,7 +607,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		values = newValues;
 	}
 	
-	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements SORTED_MAP.FastSortedSet KEY_VALUE_GENERIC_TYPE {
+	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -862,20 +844,9 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		public void clear() {
 			LINKED_HASH_MAP.this.clear();
 		}
-		
-		@Override
-		public Comparator<MAP.Entry KEY_VALUE_GENERIC_TYPE> comparator() {
-			return null;
-		}
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> subSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement, MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> headSet(MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> tailSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
-	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
 #if TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -905,9 +876,7 @@ 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();
-		}
+		public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
@@ -1089,23 +1058,11 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			int result = 0;
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.TEST_VALUE(keys[index])) return result++;
+				if(filter.TEST_VALUE(keys[index])) result++;
 				index = (int)links[index];
 			}
 			return result;
 		}
-		
-		@Override
-		public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-		
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
 	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
@@ -1371,7 +1328,6 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G

 		@Override
 		public void add(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
-		
 	}
 	
 	private class MapIterator {
@@ -1441,7 +1397,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			if(previous == -1) firstIndex = next;
 			else links[previous] ^= ((links[previous] ^ (next & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
 			
-			if (next == -1) lastIndex = previous;
+			if(next == -1) lastIndex = previous;
 			else links[next] ^= ((links[next] ^ ((previous & 0xFFFFFFFFL) << 32)) & 0xFFFFFFFF00000000L);
 			if(current == nullIndex) {
 				current = -1;
@@ -287,7 +287,8 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 #if !VALUE_OBJECT
 	@Override
 	public boolean containsValue(VALUE_TYPE value) {
-		for(int i = nullIndex;i >= 0;i--)
+		if(containsNull && VALUE_EQUALS(values[nullIndex], value)) return true;
+		for(int i = nullIndex-1;i >= 0;i--)
 			if(KEY_EQUALS_NOT_NULL(keys[i]) && VALUE_EQUALS(values[i], value)) return true;
 		return false;
 	}
@@ -296,7 +297,12 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	@Override
 	@ValuePrimitive
 	public boolean containsValue(Object value) {
-		for(int i = nullIndex;i >= 0;i--)
+#if VALUE_OBJECT
+		if(containsNull && VALUE_EQUALS(values[nullIndex], value)) return true;
+#else
+		if(containsNull && ((value == null && values[nullIndex] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[nullIndex], value))) return true;
+#endif
+		for(int i = nullIndex-1;i >= 0;i--)
 #if VALUE_OBJECT
 			if(KEY_EQUALS_NOT_NULL(keys[i]) && EQUALS_VALUE_TYPE(values[i], value)) return true;
 #else
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.maps.impl.immutable;

 import java.util.Arrays;
-import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
@@ -11,7 +10,6 @@ import java.util.function.BiFunction;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #endif
 #if !TYPE_OBJECT && !VALUE_BOOLEAN
@@ -24,11 +22,10 @@ import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 #endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
@@ -71,7 +68,6 @@ import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOpera

 #endif
 import speiger.src.collections.objects.lists.ObjectListIterator;
-import speiger.src.collections.objects.sets.ObjectSortedSet;
 #endif
 import speiger.src.collections.objects.sets.AbstractObjectSet;
 import speiger.src.collections.objects.sets.ObjectSet;
@@ -85,7 +81,7 @@ import speiger.src.collections.utils.SanityChecks;
 * @Type(T)
 * @ValueType(V)
 */
-public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing keys array */
 	protected transient KEY_TYPE[] keys;
@@ -465,15 +461,6 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		return map;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public void forEach(BI_CONSUMER KEY_VALUE_GENERIC_TYPE action) {
 		int index = firstIndex;
@@ -597,7 +584,7 @@ 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 SORTED_MAP.FastSortedSet KEY_VALUE_GENERIC_TYPE {
+	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -810,20 +797,9 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 		@Override
 		public void clear() { throw new UnsupportedOperationException(); }
-		
-		@Override
-		public Comparator<MAP.Entry KEY_VALUE_GENERIC_TYPE> comparator() {
-			return null;
-		}
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> subSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement, MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> headSet(MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> tailSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
-	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
 #if TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -1024,18 +1000,6 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			}
 			return result;
 		}
-		
-		@Override
-		public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-		
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
 	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
@@ -1,6 +1,5 @@
 package speiger.src.collections.PACKAGE.maps.impl.misc;

-import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
@@ -10,16 +9,14 @@ import java.util.Objects;

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -32,7 +29,6 @@ import speiger.src.collections.VALUE_PACKAGE.lists.VALUE_LIST_ITERATOR;
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectSortedSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 #endif

@@ -43,7 +39,7 @@ import speiger.src.collections.objects.sets.ObjectSet;
 * @Type(T)
 * @ValueType(V)
 */
-public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected long[] links;
@@ -270,20 +266,6 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		return map;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		return null;
-	}
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(T fromKey, T toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(T toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(T fromKey) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public T FIRST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
@@ -434,7 +416,7 @@ 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 SORTED_MAP.FastSortedSet KEY_VALUE_GENERIC_TYPE {
+	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -559,20 +541,9 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		public void clear() {
 			LINKED_ENUM_MAP.this.clear();
 		}
-		
-		@Override
-		public Comparator<MAP.Entry KEY_VALUE_GENERIC_TYPE> comparator() {
-			return null;
-		}
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> subSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement, MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> headSet(MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> tailSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
-	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
 #if TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -685,17 +656,6 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		}
 		
 #endif
-		@Override
-		public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-		
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(T fromElement, T toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(T toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(T fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
 	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
@@ -363,19 +363,6 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	}
 	
 #endif
-	@Override
-	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE putAndMoveToLast(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(); }
-	@Override
-	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }

@@ -1067,14 +1054,6 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 #endif		
 		@Override
 		public boolean add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
@@ -1543,18 +1522,6 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		protected Node KEY_VALUE_GENERIC_TYPE absHighFence() { return (toEnd ? null : (hiInclusive ? map.findHigherNode(hi) : map.findCeilingNode(hi))); }
 		protected Node KEY_VALUE_GENERIC_TYPE absLowFence() { return (fromStart ? null : (loInclusive ?  map.findLowerNode(lo) : map.findFloorNode(lo))); }
 		
-		@Override
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE putAndMoveToLast(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(); }
-		@Override
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return map.comparator(); }
 		
@@ -366,19 +366,6 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	}
 	
 #endif
-	@Override
-	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE putAndMoveToLast(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(); }
-	@Override
-	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }

@@ -1125,15 +1112,6 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 #endif
 		@Override
 		public boolean add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
 			if(map instanceof RB_TREE_MAP) return ((RB_TREE_MAP KEY_VALUE_GENERIC_TYPE)map).keyIterator(fromElement);
@@ -1601,18 +1579,6 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		protected Node KEY_VALUE_GENERIC_TYPE absHighFence() { return (toEnd ? null : (hiInclusive ? map.findHigherNode(hi) : map.findCeilingNode(hi))); }
 		protected Node KEY_VALUE_GENERIC_TYPE absLowFence() { return (fromStart ? null : (loInclusive ?  map.findLowerNode(lo) : map.findFloorNode(lo))); }
 		
-		@Override
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE putAndMoveToLast(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(); }
-		@Override
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return map.comparator(); }
 		
@@ -0,0 +1,95 @@
+package speiger.src.collections.PACKAGE.maps.interfaces;
+
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/**
+ * A type specific ConcurrentMap interface that reduces boxing/unboxing.
+ * Since the interface adds nothing new. It is there just for completion sake.
+ * @Type(T)
+ * @ValueType(V)
+ */
+public interface CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE extends ConcurrentMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
+{
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE compute(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		return MAP.super.compute(key, mappingFunction);
+	}
+
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE computeIfAbsent(CLASS_TYPE key, Function<? super CLASS_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		return MAP.super.computeIfAbsent(key, mappingFunction);
+	}
+
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE computeIfPresent(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		return MAP.super.computeIfPresent(key, mappingFunction);
+	}
+
+	@Override
+	@Primitive
+	public default void forEach(BiConsumer<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE> action) {
+		MAP.super.forEach(action);
+	}
+
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE merge(CLASS_TYPE key, CLASS_VALUE_TYPE value, BiFunction<? super CLASS_VALUE_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		return MAP.super.merge(key, value, mappingFunction);
+	}
+	
+#if TYPE_OBJECT && VALUE_OBJECT
+	@Override
+	public CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue);
+	@Override
+	public CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value);
+	@Override
+	public boolean remove(Object key, Object value);
+	@Override
+	public boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue);
+	@Override
+	public CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value);
+	
+#else
+	@Primitive
+	@Override
+	public default CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue) {
+		return MAP.super.getOrDefault(key, defaultValue);
+	}
+	
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
+		return MAP.super.putIfAbsent(key, value);
+	}
+	
+	@Override
+	@Deprecated
+	public default boolean remove(Object key, Object value) {
+		return MAP.super.remove(key, value);
+	}
+	
+	@Override
+	@Deprecated
+	public default boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue) {
+		return MAP.super.replace(key, oldValue, newValue);
+	}
+	
+	@Override
+	@Deprecated
+	public default CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
+		return MAP.super.replace(key, value);
+	}
+	
+#endif
+	@Override
+	@Deprecated
+	public default void replaceAll(BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		MAP.super.replaceAll(mappingFunction);
+	}
+}
@@ -31,6 +31,7 @@ import speiger.src.collections.PACKAGE.maps.impl.immutable.IMMUTABLE_HASH_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.tree.AVL_TREE_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.tree.RB_TREE_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.misc.ARRAY_MAP;
+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;
@@ -1508,6 +1509,14 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 			return putElements(new LINKED_CUSTOM_HASH_MAPKV_BRACES(size, strategy));
 		}
 		
+		/**
+		 * Builds the Keys and Values into a Concurrent Hash Map
+		 * @return a CONCURRENT_HASH_MAP
+		 */
+		public CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE concurrentMap() {
+			return putElements(new CONCURRENT_HASH_MAPKV_BRACES(size));
+		}
+		
 		/**
 		 * Builds the Keys and Values into a Array Map
 		 * @return a ARRAY_MAP
@@ -1,6 +1,8 @@
 package speiger.src.collections.PACKAGE.maps.interfaces;

 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
+import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
+import speiger.src.collections.objects.sets.ObjectOrderedSet;
 /**
 * A Special Map Interface giving Access to some really usefull functions
 * The Idea behind this interface is to allow access to functions that give control to the Order of elements.
@@ -98,6 +100,7 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	 * @return a new SortedMap that is synchronized
 	 * @see MAPS#synchronize
 	 */
+	@Override
 	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize() { return MAPS.synchronize(this); }
 	
 	/**
@@ -106,6 +109,7 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	 * @return a new SortedMap Wrapper that is synchronized
 	 * @see MAPS#synchronize
 	 */
+	@Override
 	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize(Object mutex) { return MAPS.synchronize(this, mutex); }
 	
 	/**
@@ -113,5 +117,22 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	 * @return a new SortedMap Wrapper that is unmodifiable
 	 * @see MAPS#unmodifiable
 	 */
+	@Override
 	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); }
+	
+	/**
+	 * Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
+	 * @Type(T)
+	 * @ValueType(V)
+	 */
+	interface FastOrderedSet KEY_VALUE_GENERIC_TYPE extends MAP.FastEntrySet KEY_VALUE_GENERIC_TYPE, ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
+		@Override
+		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator();
+		/**
+		 * Fast iterator that recycles the given Entry object to improve speed and reduce object allocation
+		 * @param fromElement that is going to be started from.
+		 * @return a improved iterator that starts from the desired element
+		 */
+		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator(KEY_TYPE fromElement);
+	}
 }
@@ -22,65 +22,8 @@ import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 * @note ORDERED_MAP is only extended until 0.6.0 for Compat reasons.
 * The supported classes already implement ORDERED_MAP directly and will remove SORTED_MAP implementations in favor of ORDERED_MAP instead
 */
-public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE, CLASS_VALUE_TYPE>, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
 {
-	/**
-	 * A customized put method that allows you to insert into the first index.
-	 * @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)
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#putAndMoveToFirst instead (removed in 0.6.0)
-	 */
-	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value);
-	/**
-	 * A customized put method that allows you to insert into the last index. (This may be nessesary depending on the implementation)
-	 * @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)
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#putAndMoveToLast instead (removed in 0.6.0)
-	 */
-	public VALUE_TYPE putAndMoveToLast(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
-	 * @return true if the value was moved.
-	 * @note returns false if the value was not present in the first place
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#moveToFirst instead (removed in 0.6.0)
-	 */
-	public boolean moveToFirst(KEY_TYPE key);
-	/**
-	 * A specific move method to move a given key/value to the last index.
-	 * @param key that should be moved to the first last
-	 * @return true if the value was moved.
-	 * @note returns false if the value was not present in the first place
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#moveToLast instead (removed in 0.6.0)
-	 */
-	public boolean moveToLast(KEY_TYPE key);
-	
-	/**
-	 * A Specific get method that allows to move teh given key/value int the first index.
-	 * @param key that is searched for
-	 * @return the given value for the requested key or default return value
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#getAndMoveToFirst instead (removed in 0.6.0)
-	 */
-	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key);
-	/**
-	 * A Specific get method that allows to move teh given key/value int the last index.
-	 * @param key that is searched for
-	 * @return the given value for the requested key or default return value
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#getAndMoveToLast instead (removed in 0.6.0)
-	 */
-	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key);
-	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator();
 	
@@ -227,6 +170,11 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	interface FastSortedSet KEY_VALUE_GENERIC_TYPE extends MAP.FastEntrySet KEY_VALUE_GENERIC_TYPE, ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator();
+		/**
+		 * Fast iterator that recycles the given Entry object to improve speed and reduce object allocation
+		 * @param fromElement that is going to be started from.
+		 * @return a improved iterator that starts from the desired element
+		 */
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator(KEY_TYPE fromElement);
 	}
 }
@@ -258,18 +258,43 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		return true;
 	}
 	
+#if TYPE_OBJECT
 	@Override
-	public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+	public KEY_TYPE addOrGet(KEY_TYPE o) {
+		validate(o);
+		if(tree == null) {
+			tree = first = last = new EntryBRACES(o, null);
+			size++;
+			return o;
+		}
+		int compare = 0;
+		Entry KEY_GENERIC_TYPE parent = tree;
+		while(true) {
+			if((compare = compare(o, parent.key)) == 0) return parent.key;
+			if(compare < 0) {
+				if(parent.left == null) break;
+				parent = parent.left;
+			}
+			else if(compare > 0) {
+				if(parent.right == null) break;
+				parent = parent.right;
+			}
+		}
+		Entry KEY_GENERIC_TYPE adding = new EntryBRACES(o, parent);
+		if(compare < 0)  {
+			parent.left = adding;
+			if(parent == first)	first = adding;
+		}
+		else  {
+			parent.right = adding;
+			if(parent == last) last = adding;
+		}
+		fixAfterInsertion(adding);
+		size++;
+		return o;
+	}
 	
+#endif
 	@Override
 	public KEY_TYPE lower(KEY_TYPE e) {
 		Entry KEY_GENERIC_TYPE node = findLowerNode(e);
@@ -1166,15 +1191,6 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			return entry.key;
 		}
 		
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public SubSet KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 		
@@ -14,6 +14,11 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 */
 public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
 {
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+	
+#endif
 	@Override
 	public abstract ITERATOR KEY_GENERIC_TYPE iterator();
 	@Override
@@ -3,7 +3,6 @@ package speiger.src.collections.PACKAGE.sets;
 import java.util.Arrays;
 import java.util.Collection;
 #if TYPE_OBJECT
-import java.util.Comparator;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
@@ -21,7 +20,6 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.utils.ObjectArrays;
 #endif
@@ -36,7 +34,7 @@ import speiger.src.collections.PACKAGE.utils.ARRAYS;
 * This implementation does not shrink the backing array
 * @Type(T)
 */
-public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
+public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing Array */
 	protected transient KEY_TYPE[] data;
@@ -132,6 +130,17 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return false;
 	}
 	
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) {
+		int index = findIndex(o);
+		if(index != -1) return data[index];
+		if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
+		data[size++] = o;
+		return o;
+	}
+	
+#endif
 	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) {
 		int index = findIndex(o);
@@ -499,31 +508,6 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		throw new NoSuchElementException();
 	}
 	
-	/**
-	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
-	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
-	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
-	 * @throws UnsupportedOperationException because it is not supported
-	 */
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	/**
-	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
-	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
-	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
-	 * @throws UnsupportedOperationException because it is not supported
-	 */
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	/**
-	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
-	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
-	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
-	 * @throws UnsupportedOperationException because it is not supported
-	 */
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-	
 	public ARRAY_SET KEY_GENERIC_TYPE copy() {
 		ARRAY_SET KEY_GENERIC_TYPE set = new ARRAY_SETBRACES();
 		set.data = Arrays.copyOf(data, data.length);
@@ -531,11 +515,6 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return set;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		return null;
-	}
-	
 	@Override
 	public void clear() {
 		size = 0;
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.sets;

 #if TYPE_OBJECT
-import java.util.Comparator;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
@@ -15,7 +14,6 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
@@ -34,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks;
 * Extra to that there is a couple quality of life functions provided
 * @Type(T)
 */
-public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
+public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing keys array */
 	protected transient KEY_TYPE[] keys;
@@ -241,6 +239,10 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	
 	@Override
 	public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#endif
 	@Override
 	@Primitive
 	public boolean addAll(Collection<? extends CLASS_TYPE> c) { throw new UnsupportedOperationException(); }
@@ -455,18 +457,6 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		return set;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public void clear() { throw new UnsupportedOperationException(); }
 	
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.sets;

 #if TYPE_OBJECT
-import java.util.Comparator;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
@@ -16,9 +15,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 !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
-#endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -37,7 +33,7 @@ import speiger.src.collections.utils.SanityChecks;
 * This implementation of SortedSet does not support SubSet of any kind. It implements the interface due to sortability and first/last access
 * @Type(T)
 */
-public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
+public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;
@@ -672,18 +668,6 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		return set;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-	
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		int previous = -1;
 		int next = -1;
@@ -1,8 +1,5 @@
 package speiger.src.collections.PACKAGE.sets;

-#if TYPE_OBJECT
-import java.util.Comparator;
-#endif
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
@@ -19,7 +16,6 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #endif
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
@@ -38,7 +34,7 @@ import speiger.src.collections.utils.SanityChecks;
 * This implementation of SortedSet does not support SubSet of any kind. It implements the interface due to sortability and first/last access
 * @Type(T)
 */
-public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
+public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;
@@ -643,18 +639,6 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		return set;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-	
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		int previous = -1;
 		int next = -1;
@@ -277,6 +277,30 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 		return true;
 	}
 	
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) {
+		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
+			if(containsNull) return EMPTY_KEY_VALUE;
+			containsNull = true;
+			onNodeAdded(nullIndex);
+		}
+		else {
+			int pos = HashUtil.mix(strategy.hashCode(o)) & mask;
+			KEY_TYPE current = keys[pos];
+			if(!strategy.equals(current, EMPTY_KEY_VALUE)) {
+				if(strategy.equals(current, o)) return current;
+				while(!strategy.equals((current = keys[pos = (++pos & mask)]), EMPTY_KEY_VALUE))
+					if(strategy.equals(current, o)) return current;
+			}
+			keys[pos] = o;
+			onNodeAdded(pos);
+		}
+		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
+		return o;
+	}
+	
+#endif
 	@Override
 	@Primitive
 	public boolean addAll(Collection<? extends CLASS_TYPE> c) {
@@ -235,6 +235,30 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 		return true;
 	}
 	
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) {
+		if(KEY_EQUALS_NULL(o)) {
+			if(containsNull) return null;
+			containsNull = true;
+			onNodeAdded(nullIndex);
+		}
+		else {
+			int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask;
+			KEY_TYPE current = keys[pos];
+			if(KEY_EQUALS_NOT_NULL(current)) {
+				if(KEY_EQUALS(current, o)) return current;
+				while(KEY_EQUALS_NOT_NULL((current = keys[pos = (++pos & mask)])))
+					if(KEY_EQUALS(current, o)) return current;
+			}
+			keys[pos] = o;
+			onNodeAdded(pos);
+		}
+		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
+		return o;
+	}
+	
+#endif
 	@Override
 	@Primitive
 	public boolean addAll(Collection<? extends CLASS_TYPE> c) {
@@ -258,18 +258,43 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		return true;
 	}
 	
+#if TYPE_OBJECT
 	@Override
-	public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+	public KEY_TYPE addOrGet(KEY_TYPE o) {
+		validate(o);
+		if(tree == null) {
+			tree = first = last = new EntryBRACES(o, null);
+			size++;
+			return o;
+		}
+		int compare = 0;
+		Entry KEY_GENERIC_TYPE parent = tree;
+		while(true) {
+			if((compare = compare(o, parent.key)) == 0) return parent.key;
+			if(compare < 0) {
+				if(parent.left == null) break;
+				parent = parent.left;
+			}
+			else if(compare > 0) {
+				if(parent.right == null) break;
+				parent = parent.right;
+			}
+		}
+		Entry KEY_GENERIC_TYPE adding = new EntryBRACES(o, parent);
+		if(compare < 0)  {
+			parent.left = adding;
+			if(parent == first)	first = adding;
+		}
+		else  {
+			parent.right = adding;
+			if(parent == last) last = adding;
+		}
+		fixAfterInsertion(adding);
+		size++;
+		return o;
+	}
 	
+#endif
 	@Override
 	public KEY_TYPE lower(KEY_TYPE e) {
 		Entry KEY_GENERIC_TYPE node = findLowerNode(e);
@@ -1227,15 +1252,6 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			return entry.key;
 		}
 		
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public SubSet KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 		
@@ -54,6 +54,15 @@ public interface SET KEY_GENERIC_TYPE extends Set<CLASS_TYPE>, COLLECTION KEY_GE
 		return COLLECTION.super.remove(o);
 	}
 	
+#else
+	/**
+	 * A Helper method that allows to add a element or getting the already present implement.
+	 * Allowing to make unique references reuseable.
+	 * @param o the element to add
+	 * @return either the inserted element or the present element.
+	 */
+	public KEY_TYPE addOrGet(KEY_TYPE o);
+	
 #endif
 #if !TYPE_BOOLEAN
 	/**
@@ -19,47 +19,8 @@ import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 * @note ORDERED_SET is only extended until 0.6.0 for Compat reasons.
 * The supported classes already implement ORDERED_SET directly and will remove SORTED_SET implementations in favor of ORDERED_SET instead
 */
-public interface SORTED_SET KEY_GENERIC_TYPE extends ORDERED_SET KEY_GENERIC_TYPE, SortedSet<CLASS_TYPE>
+public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, SortedSet<CLASS_TYPE>
 {
-	
-	/**
-	 * A customized add method that allows you to insert into the first index.
-	 * @param o the element that should be inserted
-	 * @return true if it was added
-	 * @see java.util.Set#add(Object)
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_SET#addAndMoveToFirst instead (removed in 0.6.0)
-	 */
-	public boolean addAndMoveToFirst(KEY_TYPE o);
-	/**
-	 * A customized add method that allows you to insert into the last index.
-	 * @param o the element that should be inserted
-	 * @return true if it was added
-	 * @see java.util.Set#add(Object)
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_SET#addAndMoveToLast instead (removed in 0.6.0)
-	 */
-	public boolean addAndMoveToLast(KEY_TYPE o);
-	
-	/**
-	 * A specific move method to move a given key to the first index.
-	 * @param o that should be moved to the first index
-	 * @return true if the value was moved.
-	 * @note returns false if the value was not present in the first place
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_SET#moveToFirst instead (removed in 0.6.0)
-	 */
-	public boolean moveToFirst(KEY_TYPE o);
-	/**
-	 * A specific move method to move a given key to the last index.
-	 * @param o that should be moved to the first last
-	 * @return true if the value was moved.
-	 * @note returns false if the value was not present in the first place
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_SET#moveToLast instead (removed in 0.6.0)
-	 */
-	public boolean moveToLast(KEY_TYPE o);
-	
 	/**
 	 * A Type Specific Comparator method
 	 * @return the type specific comparator
@@ -0,0 +1,891 @@
+package speiger.src.collections.PACKAGE.utils;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.locks.LockSupport;
+import java.util.function.Consumer;
+
+#if !TYPE_OBJECT
+
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
+#else
+import java.util.function.BiFunction;
+
+#endif
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.functions.TASK;
+import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+#if !TYPE_BOOLEAN
+import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
+#endif
+#if !TYPE_BOOLEAN
+import speiger.src.collections.booleans.utils.BooleanAsyncBuilder;
+import speiger.src.collections.booleans.utils.BooleanAsyncBuilder.BaseBooleanTask;
+#endif
+#if !TYPE_OBJECT
+import speiger.src.collections.objects.utils.ObjectAsyncBuilder;
+import speiger.src.collections.objects.utils.ObjectAsyncBuilder.BaseObjectTask;
+#endif
+#if !TYPE_INT
+import speiger.src.collections.ints.utils.IntAsyncBuilder;
+import speiger.src.collections.ints.utils.IntAsyncBuilder.BaseIntTask;
+#endif
+import speiger.src.collections.utils.SanityChecks;
+
+/**
+ * 
+ * 
+ * The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity. <br> 
+ * It uses the Lightweight Stream Replace API to do its work, which can make it faster then sequential streams. <br>
+ * This feature isn't designed to do Multithreading work, but to allow moving work off the main thread into a worker thread. <br>
+ * So anything executed on this is still Singlethreaded. <br>
+ * <br>
+ * How it works is you create the AsyncBuilder using a Iterable of the Type. <br>
+ * Then select things you want to use on the Iterable. <br>
+ * - For example: map/filter/peek/limit/etc <br>
+ * <br>
+ * After that you select your action the Iterable should be applied on. <br>
+ * - For Example: forEach/findFirst/matchAny/etc <br>
+ * <br>
+ * Then optionally a custom Executor or callback can be applied <br>
+ * At the end either execute or join can be called to start the task. <br>
+ * - execute will return the Task reference so that the task can be traced back. <br>
+ * - join will await the completion of the task and return the return value <br>
+ * <br>
+ * During Construction a couple Disposable Builder Objects will be created. <br>
+ * These will be only used during construction. <br>
+ * <br>
+ * The Task Object is also pause-able/Interruptable at any moment during the Processing. <br>
+ * 
+ * A small example
+ * <pre><code>
+ * public void processFiles(ObjectCollection&#60;String&#62; potentialFiles) {
+ * 	potentialFiles.asAsync()
+ * 		.map(Paths::get).filter(Files::exists) //Modifies the collection (Optional)
+ * 		.forEach(Files::delete) //Creates the action (Required)
+ * 		.onCompletion(T -&#62; {}} //Callback on completion (Optional)
+ * 		.execute() //Starts the task. (Required)
+ * }
+ * </code></pre>
+ * @author Speiger
+ * 
+ * @Type(T)
+ */
+public class ASYNC_BUILDER KEY_GENERIC_TYPE
+{
+	ITERABLE KEY_GENERIC_TYPE iterable;
+	BASE_TASK KEY_GENERIC_TYPE task;
+	
+	/**
+	 * Main Constructor that uses a Iterable to build a Offthread Task.
+	 * @param iterable that should be processed
+	 */
+	public ASYNC_BUILDER(ITERABLE KEY_GENERIC_TYPE iterable) {
+		this.iterable = iterable;
+	}
+	
+	/**
+	 * Helper constructor.
+	 * @param task that had been build
+	 */
+	public ASYNC_BUILDER(BASE_TASK KEY_GENERIC_TYPE task) {
+		this.task = task;
+	}
+	
+	/**
+	 * Helper function that automatically wraps a Iterable into a AsyncBuilder since it forces this collections Iterable.
+	 * @param iterable that should be wrapped
+	 * @Type(T)
+	 * @return a AsyncBuilder with the iterable wrapped
+	 */
+	public static GENERIC_KEY_BRACES ASYNC_BUILDER KEY_GENERIC_TYPE of(Iterable<CLASS_TYPE> iterable) {
+		return new ASYNC_BUILDERBRACES(ITERABLES.wrap(iterable));
+	}
+	
+	/**
+	 * Maps the elements to something else
+	 * @param mapper the mapping function
+	 * @param <E> The return type.
+	 * @return a new Builder Object with the mapped Iterable
+	 */
+	public <E> ObjectAsyncBuilder<E> map(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E> mapper) {
+		return new ObjectAsyncBuilder<>(ITERABLES.map(iterable, mapper));
+	}
+	
+	/**
+	 * Maps the elements to something else
+	 * @param mapper the flatMapping function
+	 * @param <V> The return type supplier.
+	 * @param <E> The return type.
+	 * @return a new Builder Object with the mapped Iterable
+	 */
+	public <E, V extends Iterable<E>> ObjectAsyncBuilder<E> flatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<V> mapper) {
+		return new ObjectAsyncBuilder<>(ITERABLES.flatMap(iterable, mapper));
+	}
+	
+	/**
+	 * Maps the elements to something else
+	 * @param mapper the flatMapping function
+	 * @param <E> The return type.
+	 * @return a new Builder Object with the mapped Iterable
+	 */
+	public <E> ObjectAsyncBuilder<E> arrayflatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E[]> mapper) {
+		return new ObjectAsyncBuilder<>(ITERABLES.arrayFlatMap(iterable, mapper));
+	}
+	
+	/**
+	 * Filters out the unwanted elements out of the Iterable
+	 * @param filter the elements that should be kept
+	 * @return Self with a filter applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE filter(PREDICATE KEY_GENERIC_TYPE filter) {
+		iterable = ITERABLES.filter(iterable, filter);
+		return this;
+	}
+	
+	/**
+	 * Removes duplicated elements out of the Iterable
+	 * @return Self with a deduplicator applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE distinct() {
+		iterable = ITERABLES.distinct(iterable);
+		return this;
+	}
+	
+	/**
+	 * Limits how many elements are inside of the Iterable
+	 * @param limit how many elements should max be iterated through
+	 * @return self with a limiter applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE limit(long limit) {
+		iterable = ITERABLES.limit(iterable, limit);
+		return this;
+	}
+	
+	/**
+	 * Allows to preview elements before they are processed
+	 * @param action the action that should be applied
+	 * @return self with a preview applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE peek(CONSUMER KEY_GENERIC_TYPE action) {
+		iterable = ITERABLES.peek(iterable, action);
+		return this;
+	}
+	
+	/**
+	 * Iterates over the Iterable with a desired action
+	 * @param action that should be applied
+	 * @return a new Builder with the forEach action applied.
+	 */
+	public ObjectAsyncBuilder<Void> forEach(CONSUMER KEY_GENERIC_TYPE action) {
+		return new ObjectAsyncBuilder<>(new ForEachTask<>(iterable.iterator(), action));
+	}
+	
+	/**
+	 * Reduces the elements inside of the Iterable down to one element
+	 * @param operator that reduces the elements.
+	 * @return self with the reduce action applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		task = new SimpleReduceTaskBRACES(iterable.iterator(), operator);
+		return this;
+	}
+	
+#if TYPE_OBJECT
+	/**
+	 * Reduces the elements inside of the Iterable down to one element using a identity element.
+	 * @param <E> the return type
+	 * @param identity the element the reduce function should start with
+	 * @param operator that reduces the elements.
+	 * @return a new Builder with the reduce function applied
+	 */
+	public <KEY_SPECIAL_TYPE> ASYNC_BUILDER<KEY_SPECIAL_TYPE> reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		return new ASYNC_BUILDERBRACES(new ReduceTaskBRACES(iterable.iterator(), operator, identity));
+	}
+	
+#else
+	/**
+	 * Reduces the elements inside of the Iterable down to one element using a identity element.
+	 * @param identity the element the reduce function should start with
+	 * @param operator that reduces the elements.
+	 * @return a new Builder with the reduce function applied
+	 */
+	public ASYNC_BUILDER reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		return new ASYNC_BUILDERBRACES(new ReduceTaskBRACES(iterable.iterator(), operator, identity));
+	}
+	
+#endif
+	/**
+	 * Pours all elements into a List that can be later
+	 * @return a new Builder with the pour function applied
+	 */
+	public ObjectAsyncBuilder<LIST KEY_GENERIC_TYPE> pourAsList() {
+		return pour(new ARRAY_LISTBRACES());
+	}
+	
+#if !TYPE_BOOLEAN
+	/**
+	 * Pours all elements into a Set that can be later
+	 * @return a new Builder with the pour function applied
+	 */
+	public ObjectAsyncBuilder<SET KEY_GENERIC_TYPE> pourAsSet() {
+		return pour(new LINKED_HASH_SETBRACES());
+	}
+	
+#endif
+	/**
+	 * Pours all elements into a collection that can be later
+	 * @param <E> the return type
+	 * @param collection the collection the elements
+	 * @return a new Builder with the pour function applied
+	 */
+	public <E extends COLLECTION KEY_GENERIC_TYPE> ObjectAsyncBuilder<E> pour(E collection) {
+		return new ObjectAsyncBuilder<>(new CollectTask<>(iterable.iterator(), collection));
+	}
+	
+	/**
+	 * Searches through the elements of the Iterable to find if the desired element is present.
+	 * @param filter that decides the desired elements
+	 * @return a new Builder with the matchAny function applied
+	 */
+	public BooleanAsyncBuilder matchAny(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new BooleanAsyncBuilder(new MatchTaskBRACES(iterable.iterator(), filter, 0));
+	}
+	
+	/**
+	 * Searches through the elements of the Iterable to find if unwanted elements are present.
+	 * @param filter that decides the unwanted elements
+	 * @return a new Builder with the matchNone function applied
+	 */
+	public BooleanAsyncBuilder matchNone(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new BooleanAsyncBuilder(new MatchTaskBRACES(iterable.iterator(), filter, 1));
+	}
+	
+	/**
+	 * Searches through the elements of the Iterable to find if all the desired elements are present.
+	 * @param filter that decides the desired elements
+	 * @return a new Builder with the matchAll function applied
+	 */
+	public BooleanAsyncBuilder matchAll(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new BooleanAsyncBuilder(new MatchTaskBRACES(iterable.iterator(), filter, 2));
+	}
+	
+	/**
+	 * Searches through the elements of the Iterable to find if the desired element.
+	 * If not present it will return the default value of the type
+	 * @param filter that decides the desired elements
+	 * @return self with the findFirst function applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		task = new FindFirstTaskBRACES(iterable.iterator(), filter);
+		return this;
+	}
+	
+	/**
+	 * Counts all desired elements inside the Iterable
+	 * @param filter that decides the desired elements
+	 * @return a new Builder with the count function applied
+	 */
+	public IntAsyncBuilder count(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new IntAsyncBuilder(new CountTaskBRACES(iterable.iterator(), filter));
+	}
+	
+	/**
+	 * Optional way to add a custom executor that runs this offthread task.
+	 * Can only be set after the action was decided on.
+	 * @param executor that executes the task, defaults to {@link SanityChecks#invokeAsyncTask(Runnable) }
+	 * @return self with the executor set
+	 * @note has to be NonNull
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE executor(Executor executor) {
+		if(task == null) throw new IllegalStateException("Action is missing");
+		task.withExecutor(executor);
+		return this;
+	}
+	
+	/**
+	 * Optional way to set a callback that allows to compute actions after the task was completed.
+	 * The state of the task has to be validated by the callback.
+	 * @param callback that should be notified after completion of the task
+	 * @return self with the callback set
+	 * @note can be null
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE onCompletion(Consumer<TASK KEY_GENERIC_TYPE> callback) {
+		if(task == null) throw new IllegalStateException("Action is missing");
+		task.withCallback(callback);
+		return this;
+	}
+	
+	/**
+	 * Starts the Execution of the task without awaiting its result
+	 * @return the task object that allow to trace it.
+	 */
+	public TASK KEY_GENERIC_TYPE execute() {
+		BASE_TASK KEY_GENERIC_TYPE toRun = task;
+		toRun.begin();
+		task = null;
+		return toRun;
+	}
+	
+	/**
+	 * Starts the Execution of the task and will await its completion, returning the result.
+	 * @return the result of the task provided.
+	 * @throws ExecutionException if the task threw a exception
+	 * @throws InterruptedException if the caller thread was interrupted
+	 */
+	public KEY_TYPE join() throws ExecutionException, InterruptedException {
+		BASE_TASK KEY_GENERIC_TYPE toRun = task;
+		task = null;
+		toRun.begin();
+		return toRun.GET_KEY();
+	}
+	
+	/**
+	 * Starts the Execution of the task and will await its completion with a timeout, returning the result.
+	 * @param timeout of how long the thread should wait the task to be completed
+	 * @param unit of the desired waiting time.
+	 * @return the result of the provided task
+	 * @throws InterruptedException if the caller thread was interrupted
+	 * @throws ExecutionException if the task threw a exception
+	 * @throws TimeoutException if the timeout was reached before the task was finished
+	 */
+	public KEY_TYPE join(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+		BASE_TASK KEY_GENERIC_TYPE toRun = task;
+		task = null;
+		toRun.begin();
+		return toRun.GET_KEY(timeout, unit);
+	}
+	
+#if !TYPE_OBJECT
+	private static class ReduceTask extends BASE_TASK
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator;
+		KEY_TYPE value;
+		
+		public ReduceTask(ITERATOR KEY_GENERIC_TYPE iter, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator, KEY_TYPE value) {
+			this.iter = iter;
+			this.operator = operator;
+			this.value = value;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				value = operator.apply(value, iter.NEXT());
+			}
+			if(!iter.hasNext()) {
+				setResult(value);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			operator = null;
+#if TYPE_OBJECT
+			value = null;
+#endif
+		}
+	}
+	
+#else
+	private static class ReduceTask<T, E> extends BaseObjectTask<E>
+	{
+		ObjectIterator<T> iter;
+		BiFunction<E, T, E> operator;
+		E value;
+		
+		public ReduceTask(ITERATOR KEY_GENERIC_TYPE iter, BiFunction<E, T, E> operator, E value) {
+			this.iter = iter;
+			this.operator = operator;
+			this.value = value;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				value = operator.apply(value, iter.NEXT());
+			}
+			if(!iter.hasNext()) {
+				setResult(value);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			operator = null;
+#if TYPE_OBJECT
+			value = null;
+#endif
+		}
+	}
+	
+#endif
+	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;
+		boolean first = true;
+		KEY_TYPE value;
+		
+		public SimpleReduceTask(ITERATOR KEY_GENERIC_TYPE iter, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			this.iter = iter;
+			this.operator = operator;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				if(first) {
+					first = false;
+					value = iter.NEXT();
+				}
+				else {
+					value = operator.APPLY_VALUE(value, iter.NEXT());
+				}
+			}
+			if(!iter.hasNext()) {
+				setResult(value);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			operator = null;
+#if TYPE_OBJECT
+			value = null;
+#endif
+		}
+	}
+	
+	private static class MatchTask KEY_GENERIC_TYPE extends BaseBooleanTask
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		PREDICATE KEY_GENERIC_TYPE filter;
+		int type;
+		
+		public MatchTask(ITERATOR KEY_GENERIC_TYPE iter, PREDICATE KEY_GENERIC_TYPE filter, int type) {
+			this.iter = iter;
+			this.filter = filter;
+			this.type = type;
+			if(type < 0 || type > 2) throw new IllegalArgumentException("Type is not allowed has to be between 0-2");
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			switch(type) {
+				case 0:
+					while(shouldRun() && iter.hasNext()) {
+#if TYPE_OBJECT
+						if(filter.getBoolean(iter.NEXT())) {
+#else
+						if(filter.GET_VALUE(iter.NEXT())) {
+#endif
+							setResult(true);
+							return true;
+						}
+					}
+					break;
+				case 1:
+					while(shouldRun() && iter.hasNext()) {
+#if TYPE_OBJECT
+						if(filter.getBoolean(iter.NEXT())) {
+#else
+						if(filter.GET_VALUE(iter.NEXT())) {
+#endif
+							setResult(false);
+							return true;
+						}
+					}
+					break;
+				case 2:
+					while(shouldRun() && iter.hasNext()) {
+#if TYPE_OBJECT
+						if(!filter.getBoolean(iter.NEXT())) {
+#else
+						if(!filter.GET_VALUE(iter.NEXT())) {
+#endif
+							setResult(false);
+							return true;
+						}
+					}
+					break;
+			}
+			if(!iter.hasNext()) {
+				setResult(type >= 1);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			filter = null;
+		}
+	}
+	
+	private static class FindFirstTask KEY_GENERIC_TYPE extends BASE_TASK KEY_GENERIC_TYPE
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		PREDICATE KEY_GENERIC_TYPE filter;
+		
+		public FindFirstTask(ITERATOR KEY_GENERIC_TYPE iter, PREDICATE KEY_GENERIC_TYPE filter) {
+			this.iter = iter;
+			this.filter = filter;
+		}
+
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				KEY_TYPE entry = iter.NEXT();
+#if TYPE_OBJECT
+				if(filter.getBoolean(iter.NEXT())) {
+#else
+				if(filter.GET_VALUE(iter.NEXT())) {
+#endif
+					setResult(entry);
+					return true;
+				}
+			}
+			return !iter.hasNext();
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			filter = null;
+		}
+	}
+	
+	private static class CountTask KEY_GENERIC_TYPE extends BaseIntTask
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		PREDICATE KEY_GENERIC_TYPE filter;
+		int counted = 0;
+		
+		public CountTask(ITERATOR KEY_GENERIC_TYPE iter, PREDICATE KEY_GENERIC_TYPE filter) {
+			this.iter = iter;
+			this.filter = filter;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				if(filter.TEST_VALUE(iter.NEXT())) {
+					counted++;
+				}
+			}
+			if(!iter.hasNext())
+			{
+				setResult(counted);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			filter = null;
+		}
+	}
+	
+	private static class CollectTask KSS_GENERIC_TYPE<V, T extends COLLECTION KEY_SPECIAL_GENERIC_TYPE<V>> extends BaseObjectTask<T>
+	{
+		ITERATOR KEY_SPECIAL_GENERIC_TYPE<V> iter;
+		T collection;
+		
+		public CollectTask(ITERATOR KEY_SPECIAL_GENERIC_TYPE<V> iter, T collection) {
+			this.iter = iter;
+			this.collection = collection;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				collection.add(iter.NEXT());
+			}
+			if(!iter.hasNext()) {
+				setResult(collection);
+				collection = null;
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+		}
+	}
+	
+	private static class ForEachTask<T> extends BaseObjectTask<Void>
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		CONSUMER KEY_GENERIC_TYPE listener;
+		
+		public ForEachTask(ITERATOR KEY_GENERIC_TYPE iter, CONSUMER KEY_GENERIC_TYPE listener) {
+			this.iter = iter;
+			this.listener = listener;
+		}
+
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				listener.accept(iter.NEXT());
+			}
+			return !iter.hasNext();
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			listener = null;
+		}
+	}
+	
+	/**
+	 * Base Task of the Actions that can be performed.
+	 * Allows to simplify the actions that get executed.
+	 * @Type(T)
+	 */
+	public abstract static class BASE_TASK KEY_GENERIC_TYPE implements TASK KEY_GENERIC_TYPE
+	{
+		private static final int CREATED = 0;
+		private static final int RUNNING = 1;
+		private static final int PAUSING = 2;
+		private static final int PAUSED = 3;
+		private static final int FINISHING = 4;
+		private static final int FINISHED = 5;
+		private static final int EXCEPTIONALLY = 6;
+		private static final int CANCELLED = 7;
+		private volatile WaitNode waiter;
+		private volatile int state = CREATED;
+		Consumer<TASK KEY_GENERIC_TYPE> callback;
+		Executor executor = SanityChecks::invokeAsyncTask;
+		KEY_TYPE result;
+		Throwable excpetion;
+		
+		void withCallback(Consumer<TASK KEY_GENERIC_TYPE> callback) {
+			this.callback = callback;
+		}
+		
+		void withExecutor(Executor executor) {
+			this.executor = executor;
+		}
+		
+		void begin() {
+			executor.execute(this);
+		}
+		
+		protected abstract boolean execute() throws Exception;
+		
+		protected void onCompletion() {
+			if(callback != null) {
+				callback.accept(this);
+				callback = null;
+			}
+			executor = null;
+		}
+		
+		protected void setResult(KEY_TYPE result) {
+			this.result = result;
+		}
+		
+		@Override
+		public void run() {
+			state = RUNNING;
+			try {
+				if(execute()) {
+					state = FINISHING;
+					finishCompletion(FINISHED);
+				}
+				else if(state == PAUSING) {
+					state = PAUSED;
+				}
+			}
+			catch(Exception e) {
+				state = EXCEPTIONALLY;
+				this.excpetion = e;
+				finishCompletion(EXCEPTIONALLY);
+			}
+		}
+		
+	    private void finishCompletion(int nextState) {
+	    	WaitNode current = waiter;
+	    	waiter = null;
+	    	while(current != null) {
+                Thread t = current.thread;
+                if (t != null) {
+                    current.thread = null;
+                    LockSupport.unpark(t);
+                }
+                WaitNode next = current.next;
+                if (next == null)
+                    break;
+                current.next = null;
+                current = next;
+	    	}
+	    	state = nextState;
+	    	onCompletion();
+	    }
+		
+		@Override
+		public boolean cancel(boolean cancelIfRunnning) {
+			if(state == RUNNING && !cancelIfRunnning) return false;
+			state = CANCELLED;
+			finishCompletion(CANCELLED);
+			return true;
+		}
+		
+		@Override
+		public KEY_TYPE GET_KEY() throws InterruptedException, ExecutionException {
+	        int s = state;
+	        return report(s <= FINISHING ? awaitDone(false, 0L) : s);
+		}
+		
+		@Override
+		public KEY_TYPE GET_KEY(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+			if (unit == null) throw new NullPointerException();
+			int s = state;
+			if (s <= FINISHING && (s = awaitDone(true, unit.toNanos(timeout))) <= FINISHING) throw new TimeoutException();
+	        return report(s);
+		}
+		
+		private KEY_TYPE report(int s) throws ExecutionException {
+			if (s == FINISHED) return result;
+			if (s >= CANCELLED) throw new CancellationException();
+			throw new ExecutionException(excpetion);
+	    }
+		
+		private int awaitDone(boolean timed, long nanos) throws InterruptedException {
+			final long deadline = timed ? System.nanoTime() + nanos : 0L;
+			WaitNode q = null;
+			boolean queued = false;
+			while(true) {
+				if(Thread.interrupted()) {
+					removeWaiter(q);
+					throw new InterruptedException();
+				}
+				int s = state;
+				if(s > FINISHING) {
+					if(q != null) q.thread = null;
+					return s;
+				}
+				else if(s == FINISHING) Thread.yield();
+				else if(q == null) q = new WaitNode();
+				else if(!queued) {
+					q.next = waiter;
+					waiter = q;
+					queued = true;
+				}
+				else if(timed) {
+					nanos = deadline - System.nanoTime();
+					if(nanos <= 0L) {
+						removeWaiter(q);
+						return state;
+					}
+					LockSupport.parkNanos(this, nanos);
+				}
+				else LockSupport.park(this);
+			}
+		}
+		
+		private void removeWaiter(WaitNode node) {
+			if(node == null) return;
+			node.thread = null;
+			retry:
+			while(true) {
+				for(WaitNode prev = null, current = waiter, next = null; current != null; current = next) {
+					next = current.next;
+					if(current.thread != null) prev = current;
+					else if(prev != null) {
+						prev.next = next;
+						if(prev.thread == null) continue retry; //Previous element got removed which means another thread was editing this while we were editing.
+					}
+					else if(waiter == current) {
+						waiter = next;
+						continue retry;
+					}
+				}
+				break;
+			}
+		}
+		
+		@Override
+		public boolean isCancelled() { return state >= CANCELLED; }
+		@Override
+		public boolean isDone() { return state >= FINISHING; }
+		@Override
+		public boolean isPaused() { return state == PAUSED; }
+		@Override
+		public boolean isSuccessful() { return state == FINISHED; }
+		protected boolean shouldRun() { return state == RUNNING; }
+		
+		@Override
+		public void pause() {
+			if(state == PAUSED || state == PAUSING || state >= FINISHING) return;
+			state = PAUSING;
+		}
+		
+		@Override
+		public void awaitPausing() {
+			if(state == PAUSED) return;
+			pause();
+			if(state == PAUSING) {
+				while(state == PAUSING) {
+					Thread.yield();
+				}
+			}
+		}
+		
+		@Override
+		public void resume() {
+			if(state != PAUSED && state != PAUSING) return;
+			if(state == PAUSING) {
+				while(state == PAUSING) {
+					Thread.yield();
+				}
+			}
+			state = RUNNING;
+			executor.execute(this);
+		}
+		
+		static final class WaitNode {
+			volatile Thread thread;
+			volatile WaitNode next;
+			
+			WaitNode() {
+				thread = Thread.currentThread();
+			}
+		}
+	}
+}
@@ -207,6 +207,9 @@ public class SETS
 #endif
 		@Override
 		public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#if TYPE_OBJECT
+		public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#endif
 		@Override
 		public ITERATOR KEY_GENERIC_TYPE iterator()
 		{
@@ -234,6 +237,9 @@ public class SETS
 #if !TYPE_OBJECT
 		@Override
 		public boolean remove(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#else
+		@Override
+		public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 #endif
 		@Override
 		public EmptySet KEY_GENERIC_TYPE copy() { return this; }
@@ -354,18 +360,6 @@ public class SETS
 			s = c;
 		}
 		
-		@Override
-		@Deprecated
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return s.comparator(); }
 		@Override
@@ -404,6 +398,11 @@ public class SETS
 			s = c;
 		}
 		
+#if TYPE_OBJECT
+		@Override
+		public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		
+#endif
 		@Override
 		public SET KEY_GENERIC_TYPE copy() { return s.copy(); }
 		
@@ -546,18 +545,6 @@ public class SETS
 			s = c;
 		}
 		
-		@Override
-		@Deprecated
-		public boolean addAndMoveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToFirst(o); } }
-		@Override
-		@Deprecated
-		public boolean addAndMoveToLast(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToLast(o); } }
-		@Override
-		@Deprecated
-		public boolean moveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.moveToFirst(o); } }
-		@Override
-		@Deprecated
-		public boolean moveToLast(KEY_TYPE o) { synchronized(mutex) { return s.moveToLast(o); } }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator(){ synchronized(mutex) { return s.comparator(); } }
 		@Override
@@ -676,6 +663,11 @@ public class SETS
 			s = c;
 		}
 		
+#if TYPE_OBJECT
+		@Override
+		public KEY_TYPE addOrGet(KEY_TYPE o) { synchronized(mutex) { return s.addOrGet(o); } }
+		
+#endif
 		@Override
 		public SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } }
 		
@@ -517,24 +517,6 @@ public class MAPS
 			this.map = map;
 		}
 		
-		@Override
-		@Deprecated
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return map.comparator(); }
 		@Override
@@ -833,24 +815,6 @@ public class MAPS
 			this.map = map;
 		}
 		
-		@Override
-		@Deprecated
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToFirst(key, value); } }
-		@Override
-		@Deprecated
-		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } }
-		@Override
-		@Deprecated
-		public boolean moveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.moveToFirst(key); } }
-		@Override
-		@Deprecated
-		public boolean moveToLast(KEY_TYPE key) { synchronized(mutex) { return map.moveToLast(key); } }
-		@Override
-		@Deprecated
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.getAndMoveToFirst(key); } }
-		@Override
-		@Deprecated
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { synchronized(mutex) { return map.getAndMoveToLast(key); } }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { synchronized(mutex) { return map.comparator(); } }
 		@Override
@@ -7,6 +7,8 @@ public class HashUtil
 {
 	/** Minimum HashMap Capacity */
 	public static final int DEFAULT_MIN_CAPACITY = 16;
+	/** Minimum ConcurrentHashMap Concurrency */
+	public static final int DEFAULT_MIN_CONCURRENCY = 4;
 	/** Default HashMap Load Factor */
 	public static final float DEFAULT_LOAD_FACTOR = 0.75F;
 	/** HashMap Load Factor with reduced hash collisions but more memory usage */
@@ -104,6 +104,14 @@ public class SanityChecks
 		getPool().execute(task);
 	}
 	
+	/**
+	 * A Helper method to start a Async Task. This method will not await the finalization of said task
+	 * @param task the Task to invoke
+	 */
+	public static void invokeAsyncTask(Runnable task) {
+		getPool().execute(task);
+	}
+	
 	/**
 	 * Helper method to control what ForkJoinPool is being used for any given task.
 	 * @note this method is not thread-save. It is only there to provide control over how Library specific Threaded tasks are handled.
@@ -123,8 +123,8 @@ public abstract class BaseIntIterableTest
 	@Test
 	public void testStreamMap() {
 		if(getValidIterableTests().contains(IterableTest.STREAM_MAP)) {
-			Integer[] expected = IntStream.of(TEST_ARRAY).mapToObj(Integer::new).toArray(Integer[]::new);
-			Integer[] actual = ObjectIterators.pour(create(TEST_ARRAY).map(Integer::new).iterator()).toArray(Integer[]::new);
+			Integer[] expected = IntStream.of(TEST_ARRAY).mapToObj(Integer::valueOf).toArray(Integer[]::new);
+			Integer[] actual = ObjectIterators.pour(create(TEST_ARRAY).map(Integer::valueOf).iterator()).toArray(Integer[]::new);
 			ObjectArrays.stableSort(actual);
 			Assert.assertArrayEquals(expected, actual);
 		}
@@ -1,5 +1,8 @@
 package speiger.src.collections.objects.list;

+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.function.Function;

@@ -8,14 +11,18 @@ import com.google.common.collect.testing.TestStringListGenerator;
 import com.google.common.collect.testing.features.CollectionFeature;
 import com.google.common.collect.testing.features.CollectionSize;
 import com.google.common.collect.testing.features.ListFeature;
+import com.google.common.collect.testing.testers.ListListIteratorTester;
+import com.google.common.collect.testing.testers.ListSubListTester;

 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
+import speiger.src.collections.ints.lists.CopyOnWriteIntArrayList;
 import speiger.src.collections.ints.lists.ImmutableIntList;
 import speiger.src.collections.ints.lists.IntArrayList;
 import speiger.src.collections.ints.lists.IntLinkedList;
 import speiger.src.collections.ints.lists.IntList;
+import speiger.src.collections.objects.lists.CopyOnWriteObjectArrayList;
 import speiger.src.collections.objects.lists.ImmutableObjectList;
 import speiger.src.collections.objects.lists.ObjectArrayList;
 import speiger.src.collections.objects.lists.ObjectLinkedList;
@@ -28,9 +35,11 @@ public class ObjectListTests extends TestCase
 		TestSuite suite = new TestSuite("Lists");
 		suite.addTest(suite("ArrayList", T -> new ObjectArrayList<>(T)));
 		suite.addTest(suite("LinkedList", T -> new ObjectLinkedList<>(T)));
+		suite.addTest(copyOnWriteSuite("CopyOnWriteArrayList", T -> new CopyOnWriteObjectArrayList<>(T)));
 		suite.addTest(immutableSuite("ImmutableList", T -> new ImmutableObjectList<>(T)));
 		suite.addTest(intSuite("IntArrayList", IntArrayList::new));
 		suite.addTest(intSuite("IntLinkedList", IntLinkedList::new));
+		suite.addTest(intCopyOnWriteSuite("CopyOnWriteArrayList", CopyOnWriteIntArrayList::new));
 		suite.addTest(intImmutableSuite("IntImmutableList", ImmutableIntList::new));
 		return suite;
 	}
@@ -39,6 +48,10 @@ public class ObjectListTests extends TestCase
 		return ListTestSuiteBuilder.using(new TestIntListGenerator(factory)).named(name).withFeatures(ListFeature.GENERAL_PURPOSE, CollectionSize.ANY).createTestSuite();
 	}
 	
+	public static Test intCopyOnWriteSuite(String name, Function<int[], IntList> factory) {
+		return ListTestSuiteBuilder.using(new TestIntListGenerator(factory)).named(name).suppressing(suppressForCopyOnWriteArrayList()).withFeatures(ListFeature.SUPPORTS_SET, ListFeature.SUPPORTS_ADD_WITH_INDEX, ListFeature.SUPPORTS_REMOVE_WITH_INDEX, CollectionFeature.SUPPORTS_ADD, CollectionFeature.SUPPORTS_REMOVE, CollectionSize.ANY).createTestSuite();
+	}
+	
 	public static Test intImmutableSuite(String name, Function<int[], IntList> factory) {
 		return ListTestSuiteBuilder.using(new TestIntListGenerator(factory)).named(name).withFeatures(CollectionSize.ANY).createTestSuite();
 	}
@@ -50,10 +63,21 @@ public class ObjectListTests extends TestCase
 		}).named(name).withFeatures(ListFeature.GENERAL_PURPOSE, CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
 	}
 	
+	public static Test copyOnWriteSuite(String name, Function<String[], List<String>> factory) {
+		return ListTestSuiteBuilder.using(new TestStringListGenerator() {
+			@Override
+			protected List<String> create(String[] elements) { return factory.apply(elements); }
+		}).named(name).suppressing(suppressForCopyOnWriteArrayList()).withFeatures(ListFeature.SUPPORTS_SET, ListFeature.SUPPORTS_ADD_WITH_INDEX, ListFeature.SUPPORTS_REMOVE_WITH_INDEX, CollectionFeature.SUPPORTS_ADD, CollectionFeature.SUPPORTS_REMOVE, CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
+	}
+	
 	public static Test immutableSuite(String name, Function<String[], List<String>> factory) {
 		return ListTestSuiteBuilder.using(new TestStringListGenerator() {
 			@Override
 			protected List<String> create(String[] elements) { return factory.apply(elements); }
 		}).named(name).withFeatures(CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
 	}
+	
+	public static Collection<Method> suppressForCopyOnWriteArrayList() {
+		return Arrays.asList(ListSubListTester.getSubListSubListRemoveAffectsOriginalLargeListMethod(), ListListIteratorTester.getListIteratorFullyModifiableMethod());
+	}
 }
@@ -20,6 +20,7 @@ import com.google.common.collect.testing.features.MapFeature;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
+import speiger.src.collections.objects.maps.impl.concurrent.Object2ObjectConcurrentOpenHashMap;
 import speiger.src.collections.objects.maps.impl.customHash.Object2ObjectLinkedOpenCustomHashMap;
 import speiger.src.collections.objects.maps.impl.customHash.Object2ObjectOpenCustomHashMap;
 import speiger.src.collections.objects.maps.impl.hash.Object2ObjectLinkedOpenHashMap;
@@ -42,6 +43,7 @@ public class ObjectMapTests extends TestCase
 		suite.addTest(suite("LinkedHashMap", Object2ObjectLinkedOpenHashMap::new, true));
 		suite.addTest(suite("CustomHashMap", () -> new Object2ObjectOpenCustomHashMap<>(Strategy.INSTANCE), true));
 		suite.addTest(suite("LinkedCustomHashMap", () -> new Object2ObjectLinkedOpenCustomHashMap<>(Strategy.INSTANCE), true));
+		suite.addTest(suite("ConcurrentHashMap", Object2ObjectConcurrentOpenHashMap::new, true));
 		suite.addTest(navigableSuite("RBTreeMap_NonNull", Object2ObjectRBTreeMap::new, false));
 		suite.addTest(navigableSuite("AVLTreeMap_NonNull", Object2ObjectAVLTreeMap::new, false));
 		suite.addTest(navigableSuite("RBTreeMap_Null", () -> new Object2ObjectRBTreeMap<>(new NullFriendlyComparator()), true));
Author	SHA1	Message	Date
Speiger	26b9d6706d	Fixed Classification	2022-04-14 09:34:16 +02:00
Speiger	a21d4a9eb6	Fixing Jitpack Publishing	2022-04-14 09:24:13 +02:00
Speiger	212d614ebd	Trying switching Jitpack Java version.	2022-04-14 09:19:27 +02:00
Speiger	bcba3ccde0	Another try	2022-04-14 09:13:53 +02:00
Speiger	b42ad76372	Jitpack Test	2022-04-14 09:12:03 +02:00
Speiger	f95565771a	0.6.0 Release Commit	2022-04-14 07:56:39 +02:00
Speiger	3d6cbf5ac1	Finishing touches for the 0.6.0 release.	2022-04-14 07:29:32 +02:00
Speiger	fc5d43e14b	Updated Changelog.	2022-04-14 06:06:35 +02:00
Speiger	b3264748cd	Added Author to module Info.	2022-04-14 05:47:19 +02:00
Speiger	ede40f06d0	Small fixes. -Fixed: Some imports. -Fixed: containsValue for OpenHashMap was not checking nullEntry properly	2022-04-14 05:37:41 +02:00
Speiger	e69c675f82	Fixed bug with linux & cleanup of the java version detector	2022-04-13 02:58:35 +02:00
Speiger	17c1c90957	Added Module-Info support	2022-04-13 02:54:03 +02:00
Speiger	c6f2f71f6c	Switching to a new lock to make read operations actually concurrent.	2022-04-13 02:00:52 +02:00
Speiger	d2c7c151bc	Implemented tests. -Added: ConcurrentHashMap test suite -Fixed: Bugs found in ConcurrentHashMaps with the iterator and clear function.	2022-04-12 08:08:17 +02:00
Speiger	4448eca787	Finishing ConcurrentHashMap implementation, next tests	2022-04-12 06:06:18 +02:00
Speiger	0350a77dff	Finishing the ConcurrentMap implementation This though isn't finishing the rest because the interface still needs to be implemented. -Added: Rest of the ConcurrentMap implementation -Fixed: LinkedOpenHashMap Count method was returning prematurely.	2022-04-11 03:20:28 +02:00
Speiger	4f98c599df	New Features. -Added: ArrayList.of(CLASS, size) function that allows to preallocate the size of the generic list. -Updated: ListTests suppressors only suprres what they need to. -Added: Start of the ConcurrentHashMap implementation (based on Guavas implementation) Note that the ConcurrentHashMap implementation is just started not finished and still needs a lot of work, but the base code - any subclasses is technically finished. The implementation is also using linkedMaps to have faster iteration performance.	2022-04-10 15:49:16 +02:00
Speiger	103b2407d2	Updated Changelog	2022-04-09 04:23:57 +02:00
Speiger	059da9be12	New Features -Added: CopyOnWriteArrayList -Added: UnitTests for CopyOnWriteArrayLists	2022-04-09 03:56:54 +02:00
Speiger	3cac3a997e	And hopefully the last javaDoc fixes	2022-04-08 00:24:37 +02:00
Speiger	3ffb001c73	More fixes -Fixed: More javadoc fixes -Fixed: BaseIntIterableTest no longer uses a deprecated function	2022-04-08 00:13:51 +02:00
Speiger	2810a6f952	Small fixes -Fixed: JavaDoc -Changed: callback is now called onCompletion	2022-04-08 00:00:45 +02:00
Speiger	166362334b	Added gradle now uses the java version it runs on.	2022-04-07 20:26:53 +02:00
Speiger	d3f9103ebf	Adding Logger for testings	2022-04-07 20:19:47 +02:00
Speiger	1c5507d4a5	Switching to local properties	2022-04-07 20:16:59 +02:00
Speiger	5e3cd9f484	Trying out something with github actions	2022-04-07 20:14:23 +02:00
Speiger	f27b884b6a	Moving to a more up to date system. -Changed: Moved to gradle 7.3 for java17 support of the project. -Changed: Moved to maven-publish plugin and added a bit more info to the poms.	2022-04-07 16:00:58 +02:00
Speiger	769a9d8ea5	Upgraded gradle version to 6.3 for a test	2022-04-07 13:32:04 +02:00
Speiger	9499a7f0e0	Setup matrix so multiple java versions are tested.	2022-04-07 13:27:12 +02:00
Speiger	ca38583f96	Fixed Java11 Incompat	2022-04-07 00:14:09 +02:00
Speiger	9557a0cfb5	Merge branch 'master' of git@github.com:Speiger/Primitive-Collections.git	2022-04-07 00:08:05 +02:00
Speiger	c61e8bb7fc	New Features - Added: addOrGet for sets. - Added: Async API which allows to easily execute Iterables/Collections offthread without the complexity.	2022-04-07 00:06:49 +02:00
SpeigerandSpeiger	4fbcaa47f8	Update README.md	2022-04-07 00:06:19 +02:00
Speiger	6f31fc5abb	New Features - Added: addOrGet for sets. - Added: Async API which allows to easily execute Iterables/Collections offthread without the complexity.	2022-04-07 00:04:52 +02:00
SpeigerandGitHub	10ec0e35d0	Update README.md	2021-12-27 21:29:51 +01:00
Speiger	29c4d253cf	Disabling badge	2021-12-27 21:28:07 +01:00
Speiger	55c870d392	Adding Build Passing badge	2021-12-27 21:22:57 +01:00
SpeigerandGitHub	cda6ec066d	Adding Build Validation Create gradle.yml	2021-12-27 20:38:55 +01:00
Speiger	c8b89e6847	Renaming file for what the action did.	2021-12-27 20:34:15 +01:00
Speiger	b46a739008	Finishing Build Action	2021-12-27 20:28:45 +01:00
Speiger	af62394651	Testing for secrets to be present	2021-12-27 20:04:50 +01:00
SpeigerandGitHub	bc75a5cd97	Merge pull request #8 from Speiger/master Moving Credentials Away from this file because now i need it	2021-12-27 20:00:58 +01:00
Speiger	7d8af3af08	Moving Credentials Away from this file because now i need it	2021-12-27 19:59:19 +01:00
SpeigerandGitHub	ef8197b275	Update gradle.yml	2021-12-27 19:24:16 +01:00
SpeigerandGitHub	58d9ac7fdd	Update gradle.yml	2021-12-27 19:21:59 +01:00
SpeigerandGitHub	86a893916d	Update gradle.yml	2021-12-27 19:20:06 +01:00
SpeigerandGitHub	e7a6292fe9	Update gradle.yml	2021-12-27 19:10:09 +01:00
SpeigerandGitHub	81209b0cf8	Update gradle.yml	2021-12-27 19:07:05 +01:00
SpeigerandGitHub	77b8147f9b	Update gradle.yml	2021-12-27 19:05:33 +01:00
SpeigerandGitHub	32abd7e14e	Update gradle.yml	2021-12-27 19:04:33 +01:00
SpeigerandGitHub	8a582f0b08	Create gradle.yml	2021-12-27 19:01:45 +01:00
SpeigerandGitHub	01be6f7d43	Delete gradle.yml	2021-12-27 18:56:49 +01:00
SpeigerandGitHub	9011700879	testing build only	2021-12-27 18:55:51 +01:00
SpeigerandGitHub	12cd4e5e5f	Update gradle.yml	2021-12-27 18:50:24 +01:00
SpeigerandGitHub	10201bcadb	hopefully this works	2021-12-27 18:44:47 +01:00
SpeigerandGitHub	3b4fcc0069	Merge pull request #6 from Speiger/actions Update gradle.yml	2021-12-27 18:32:51 +01:00
SpeigerandGitHub	31a1ef74fb	Update gradle.yml	2021-12-27 18:32:23 +01:00
SpeigerandGitHub	9be3a1475f	another build try	2021-12-27 18:29:54 +01:00
SpeigerandGitHub	7591f396fd	getting into github actions Adding a build test	2021-12-27 18:18:24 +01:00