Version 0.7.0 Release

- Added: Coverage Badge
- Updated: Changelog.
- Changed: Changelog now has info how to obtain the sourcecode.
- Added: Over 11 Million Unit Tests to this library to ensure quality.
- Added: ArrayList size constructor now throws IllegalStateException if
the size parameter is negative
- Added: EnumMap specialized forEach implementation.
- Added: AbstractMap.remove now delegates to its primitive counterpart.
- Added: ConcurrentHashMap now implements ITrimmable
- Refactor: Removed a lot of disabled code from ArraySet.
- Removed: LinkedList.addAll(index, List) now delegates to
LinkedList.addAll(index, Collection) due to no special optimization
required.
- Fixed: AbstractList.SubList.get/set/swapRemove didn't calculate their
List index Properly
- Fixed: AbstractList.SubList chains now properly if you create SubLists
within SubLists.
- Fixed: AbstractList.Iterator.add now respects
Immutable/UnmodifiableLists.
- Fixed: AbstractList.Iterator.skip/back now keep track of the last
returned value for remove function to work properly.
- Fixed: CopyOnWriteArrayList.extract/removeElements(int, int) does now
proper range checks and remove elements properly.
- Fixed: CopyOnWriteArrayList.SubList now works properly. (Reimplemented
entirely)
- Fixed: CopyOnWriteArrayList.Iterator.previous() was returning the
wrong values.
- Fixed: CopyOnWriteArrayList.Iterator.skip now skips the right amount
of elements and stops where it should.
- Fixed: LinkedList.first/last/dequeue/dequeueLast now throws
NoSuchElementException when empty instead of IllegalStateException.
- Fixed: LinkedList had an edge case where the entire reverse iterator
would break if the wrong element was removed.
- Fixed: LinkedList.extractElement now returns the correct values.
- Fixed: AbstractMap.entrySet().remove(Object) now returns true if
defaultReturnValue elements were removed.
- Fixed: ConcurrentHashMap.remove(Object, Object) checks if the type
matches before comparing against null Values.
- Fixed: LinkedHashMap.clearAndTrim() was checking the wrong value for
determining the full reset or clearing of a Map.
- Fixed: HashMap.trim/clearToTrim() was using the wrong value to
determin if something should be done.
- Fixed: HashMap now compares empty values (0) against nullKeys when
Object Variants of the type are used.
- Fixed: ImmutableMap now compares empty values (0) against nullKeys
when Object Variants of the type are used.
- Fixed: ArrayMap.iterator(key) now throws NoSuchElementException when
the element wasn't found.
- Fixed: Linked/EnumMap array constructor was creating the wrong size
values array.
- Fixed: LinkedEnumMap.getAndMoveToFirst/Last was moving elements even
if the element wasn't present.
- Fixed: AVL/RBTreeMap.getFirst/LastKey was not throwing a
NoSuchElementException if the map was empty.
- Fixed: Map.Builder wasn't throwing a IllegalStateException when
creating a negative size builder.
- Fixed: AVL/RBTreeSet.DecendingSet.subSet(from, fromInclusive, to,
toInclusive) was creating a corrupt asending subset.
- Fixed: ArraySet throws now a IllegalStateException when trying to
create it with a negative size.
- Fixed: ArraySet.addMoveToLast(key) was crashing when a key was already
present.
- Fixed: Immutable/LinkedHashSet now keep track of their iteration index
properly.
- Fixed: LinkedHashSet.moveToFirst/Last(key) would crash if the Set was
empty.
- Fixed: LinkedHashSet.clearAndTrim() was checking the wrong value for
determining the full reset or clearing of a Map.
- Fixed: HashSet.trim/clearToTrim() was using the wrong value to
determin if something should be done.

.github/workflows/build_validator.yml

@@ -32,7 +32,5 @@ jobs:
       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

Changelog.md

@@ -1,5 +1,70 @@
 # Changelog of versions
 
+### Version 0.7.0
+- Added: Over 11 Million Unit Tests to this library to ensure quality.
+- Added: ArrayList size constructor now throws IllegalStateException if the size parameter is negative
+- Added: EnumMap specialized forEach implementation.
+- Added: AbstractMap.remove now delegates to its primitive counterpart.
+- Added: ConcurrentHashMap now implements ITrimmable
+- Refactor: Removed a lot of disabled code from ArraySet.
+- Removed: LinkedList.addAll(index, List) now delegates to LinkedList.addAll(index, Collection) due to no special optimization required.
+- Fixed: AbstractList.SubList.get/set/swapRemove didn't calculate their List index Properly
+- Fixed: AbstractList.SubList chains now properly if you create SubLists within SubLists.
+- Fixed: AbstractList.Iterator.add now respects Immutable/UnmodifiableLists.
+- Fixed: AbstractList.Iterator.skip/back now keep track of the last returned value for remove function to work properly.
+- Fixed: CopyOnWriteArrayList.extract/removeElements(int, int) does now proper range checks and remove elements properly.
+- Fixed: CopyOnWriteArrayList.SubList now works properly. (Reimplemented entirely)
+- Fixed: CopyOnWriteArrayList.Iterator.previous() was returning the wrong values.
+- Fixed: CopyOnWriteArrayList.Iterator.skip now skips the right amount of elements and stops where it should.
+- Fixed: LinkedList.first/last/dequeue/dequeueLast now throws NoSuchElementException when empty instead of IllegalStateException.
+- Fixed: LinkedList had an edge case where the entire reverse iterator would break if the wrong element was removed.
+- Fixed: LinkedList.extractElement now returns the correct values.
+- Fixed: AbstractMap.entrySet().remove(Object) now returns true if defaultReturnValue elements were removed.
+- Fixed: ConcurrentHashMap.remove(Object, Object) checks if the type matches before comparing against null Values.
+- Fixed: LinkedHashMap.clearAndTrim() was checking the wrong value for determining the full reset or clearing of a Map.
+- Fixed: HashMap.trim/clearToTrim() was using the wrong value to determin if something should be done.
+- Fixed: HashMap now compares empty values (0) against nullKeys when Object Variants of the type are used.
+- Fixed: ImmutableMap now compares empty values (0) against nullKeys when Object Variants of the type are used.
+- Fixed: ArrayMap.iterator(key) now throws NoSuchElementException when the element wasn't found.
+- Fixed: Linked/EnumMap array constructor was creating the wrong size values array.
+- Fixed: LinkedEnumMap.getAndMoveToFirst/Last was moving elements even if the element wasn't present.
+- Fixed: AVL/RBTreeMap.getFirst/LastKey was not throwing a NoSuchElementException if the map was empty.
+- Fixed: Map.Builder wasn't throwing a IllegalStateException when creating a negative size builder.
+- Fixed: AVL/RBTreeSet.DecendingSet.subSet(from, fromInclusive, to, toInclusive) was creating a corrupt asending subset.
+- Fixed: ArraySet throws now a IllegalStateException when trying to create it with a negative size.
+- Fixed: ArraySet.addMoveToLast(key) was crashing when a key was already present.
+- Fixed: Immutable/LinkedHashSet now keep track of their iteration index properly.
+- Fixed: LinkedHashSet.moveToFirst/Last(key) would crash if the Set was empty.
+- Fixed: LinkedHashSet.clearAndTrim() was checking the wrong value for determining the full reset or clearing of a Map.
+- Fixed: HashSet.trim/clearToTrim() was using the wrong value to determin if something should be done.
+
+
+### Version 0.6.2
+- Added: Array only sorting function return the inputed array. This was done to allow for static final references to use the method in one go without having to make lambda wrappers. Cleaner code.
+- Added: Iterator Wrappers are now a bit more in Compliance with Java Standards.
+- Added: AsyncBuilders now Support Array Inputs to create cleaner code.
+- Changed: LinkedList.addBulk variable definition was triggering a false positive.
+- Fixed: TreeMap.subMap().entrySet().remove() wouldn't check primitives properly.
+- Fixed: SortedMap.sub/tail/headMap were looping into themselves.
+- Fixed: AbstractCollection.retainAll didn't push removed values through the consumer.
+- Fixed: AbstractCollection.toArray wouldn't reset the last entry if the input array was larger then the elements in the collection.
+- Fixed: SubList didn't check for ranges properly or didn't use parent list to validate changes.
+- Fixed: ArrayList.addElements didn't check input array fully and used the wrong variable to move the elements around.
+- Fixed: LinkedList.addElements(EmptyInput) would crash.
+- Fixed: LinkedList.swapRemove didn't account for if the removed element was the prelast one.
+- Fixed: LinkedList.removeElements would break the implementation if the list was almost empty and the middle element was removed.
+- Fixed: LinkedHashSet.addAndMoveToFirst wouldn't move elements to the first place.
+- Fixed: ArrayList/LinkedList extractElements crashing when 0 or less elements are desired.
+- Fixed: TreeMap pollFirst/LastKey should return the defaultMin/max value instead of a Empty value.
+- Fixed: TreeMap keySet implementation was missing the class type implementations to pass keySet tests.
+- Fixed: TreeMap.SubMap Iterator (primitive Keys) was crashing because a Null was set on to a primitive.
+
+
+### Version 0.6.1
+- Fixed: FIFO queue crashing when the last index is before the first index when peek is called.
+- Fixed: FIFO queue only clears the array if it was in use.
+- Added: Sorted Method for the stream replacing functions.
+
 ### Version 0.6.0
 - Added: addOrGet for sets.
 - Added: Async API which allows to easily execute Iterables/Collections offthread without the complexity.

README.md

@@ -1,10 +1,18 @@
 ![build](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_validator.yml/badge.svg)
-
+[![Latest Release](https://jitpack.io/v/Speiger/Primitive-Collections.svg)](https://jitpack.io/#Speiger/Primitive-Collections)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+![GitHub commit activity](https://img.shields.io/github/commit-activity/m/Speiger/Primitive-Collections)
+[![codecov](https://codecov.io/gh/Speiger/Primitive-Collections/branch/debug/graph/badge.svg?token=WSTSNJM0EN)](https://codecov.io/gh/Speiger/Primitive-Collections)
 # Primitive-Collections
+This is a Simple Primitive Collections Library aimed to outperform Java's Collection Library and FastUtil.  
+Both in Performance and Quality of Life Features.  
 
-This is a Simple Primitive Collections Library i started as a hobby Project.     
+## Benchmarks
-It is based on Java's Collection Library and FastUtil.     
+Benchmarks can be found here: [[Charts]](https://github.com/Speiger/Primitive-Collections-Benchmarks/blob/master/BENCHMARKS-CHARTS.md), [[Tables]](https://github.com/Speiger/Primitive-Collections-Benchmarks/blob/master/BENCHMARKS.md)
-But its focus is a different one.     
+
+## Special Features
+[Here](features.md) you find a set of features added to Primitive Collections.   
+These are designed to improve performance or to provide Quality of Life.  
 
 ## Main Features:      
 - ArrayLists / LinkedLists / CopyOnWriteLists
@@ -15,106 +23,34 @@ But its focus is a different one.
 - ConcurrentHashMaps
 - Priority Queues
 - Streams & Functional Queries
-- SplitIterators
+- Split/Iterators
-- Iterators
 - Pairs
 - 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.     
-Thanks to [ben-manes](https://github.com/ben-manes) we now have Roughly 160k unit test covering Maps/Sets/Lists.     
-These tests cover Javas Collection API completely and ensuring a Stable implementation.     
-These freshly added tests allowed me to squash thousands of issues according to Googles Test Library (Guava-Tests).     
-These will be expanded on as time goes on.     
-
-### Benchmarks
-Benchmarks can be found here: [Click Me](https://github.com/Speiger/Primitive-Collections-Benchmarks/tree/master)
-
-## Specialized Functions
-New Specialized functions that were added to increase performance or reduce allocations or Quality Of life.
-To highlight things that may be wanted.
-- Iterable:
-	- map/flatMap/arrayFlatMap: A Light weight version of Stream.map().
-	- findFirst: Allows to find the first element of a Predicated Iterable.
-	- filter: Allows to filter unwanted elements for wrapped Iterable
-	- matchAny/matchNone/matchAll: Allows to find elements in a collection.
-	- count: counts all valid elements in a collection.
-	- forEach: Allows to input a second element into a forEach move allowing for more flexibility for Method References
-	- reduce/limit/peek/distinct: Light Versions of the Stream variant, to reduce Stream usage.
-	- pour: a function that allows to collect all elements within the Collection
-- Collection:
-	- addAll: addAll array version
-	- containsAny: Allows to test if another collection contains an of the elements of the tested collection.
-	- primitiveStream: Provides access to the closest Java Stream Type.
-	- copy: shallowCopies the collection, used instead of clone because this is better to use.
-		(subCollections not supported for obvious reasons)
-	- toArray: the ToArray function from Java9 and newer that uses a Functional interface and can use a method reference
-- List:
-	- add/get/removeElements (From FastUtil): Allows to add/get/remove an Array into/from a list. Just with less overhead
-	- extractElements: Allows to remove a Range of elements from the List and get what was removed.
-	- Unstable Sort(From FastUtil): Uses a faster but not stable sort (Quick-Sort as example) to sort the list.
-	- addIfAbsent/Present: adds a element only if absent/present in the list
-	- swapRemove: deletes a desired element and inserts the last element in its place instead of leftshifting elements.
-- SortedSet:
-	- addAndMoveToFirst/Last (From FastUtil but moved to Interface): Allows to add a element to the first/last position of a sorted set.
-	- moveToFirst/Last: Moves the desired element at the first/last position of the SortedSet.
-	- pollFirst/Last: Allows to poll the first/last element of the set.
-- Map:
-	- putAll: putAll but in Array form.
-	- putAllIfAbsent: Puts only the elements that are absent.
-	- addTo (Only Primitives Values) (From FastUtil but moved to Interface): allows to add to the value of a given key. If not present it will be added. (Accumulator)
-	- subFrom (Only Primitive Values): allows to subtract from the value of a given key. If value reached getDefaultReturnValue() element will be removed.
-	- addToAll: Same as addTo but bulkVersion.
-	- removeOrDefault: removes a Element and if not present returns the default value instead of the present value.
-	- mergeAll: BulkVersion of Merge function.
-	- supplyIfAbsent: A Supplier based computeIfAbsent
-- Sorted Map:
-	- addAndMoveToFirst/Last (From FastUtil but moved to Interface): Allows to add a element to the first/last position of a sorted Map.
-	- moveToFirst/Last: Moves the desired element at the first/last position of the Map.
-	- getAndMoveToFirst/Last: gets the element and moves it to the first/last position. Replicating a Optional LinkedHashMap feature.
-	- pollFirst/LastKey: Allows to poll the first/last element.
-	- first/LastValue: Allows to get the first/last value from the Map.
-	
-	
 # Notes about Versions
 Any 0.x.0 version (Minor) can be reason for massive changes including API.     
 To ensure that problems can be dealt with even if it is breaking the current API.     
-Any breaking changes will be Documented (once 1.0 is released)     
-
-Also to save space every 0.0.x (Patch) that is 2 Minor Versions behind will be removed. 
-So if 0.5.0 is released every 0.3.x patch will be deleted, except for the last patch for that minor version.
 
 # How to install
-Using Gradle:
+Using Jitpack Gradle
 ```gradle
 repositories {
     maven {
-        url = "https://maven.speiger.com/repository/main"
+        url = "https://jitpack.io"
     }
 }
 dependencies {
-	compile 'de.speiger:Primitive-Collections:0.6.0'
+	implementation 'com.github.Speiger:Primitive-Collections:0.7.0'
 }
 ```
-Direct:
 
-| Version 	| Jar                                                                                                                          	| Sources                                                                                                                              	| Java Doc                                                                                                                             	|
+# SourceCode
-|---------	|------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|
+The generated Sourcecode can be automatically build,    
-| 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) 	|
+but if you want to just browse around in it.    
-| 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) 	|
+Check out the [Debug Branch](https://github.com/Speiger/Primitive-Collections/tree/debug/src/main/java/speiger/src/collections), which has the entire up to date code.
-| 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) 	|
-| 0.5.0   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.0/Primitive-Collections-0.5.0.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.0/Primitive-Collections-0.5.0-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.0/Primitive-Collections-0.5.0-javadoc.jar) 	|
-| 0.4.5   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.5/Primitive-Collections-0.4.5.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.5/Primitive-Collections-0.4.5-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.5/Primitive-Collections-0.4.5-javadoc.jar) 	|
-| 0.4.4   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.4/Primitive-Collections-0.4.4.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.4/Primitive-Collections-0.4.4-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.4/Primitive-Collections-0.4.4-javadoc.jar) 	|
-| 0.4.3   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.3/Primitive-Collections-0.4.3.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.3/Primitive-Collections-0.4.3-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.3/Primitive-Collections-0.4.3-javadoc.jar) 	|
-| 0.4.2   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.2/Primitive-Collections-0.4.2.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.2/Primitive-Collections-0.4.2-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.2/Primitive-Collections-0.4.2-javadoc.jar) 	|
-| 0.4.1   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.1/Primitive-Collections-0.4.1.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.1/Primitive-Collections-0.4.1-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.1/Primitive-Collections-0.4.1-javadoc.jar) 	|
-| 0.4.0   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0-javadoc.jar) 	|
-| 0.3.6   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6-javadoc.jar) 	|
 
 # Contributing
 If you want to contribute.      
@@ -134,9 +70,5 @@ Please if you want to contribute follow the [Rule-Sheet](RuleSheet.md). It keeps
 The SourceCode can be generated via:     
 /gradlew.bat generateSource      
 
-to build the jar:           
+to generate SourceCode and build the jar:           
 /gradlew.bat build      
-do not combine the commands because they can not be executed at the same time.      
-
-## Current Down Sides (Random order)
-- Documentation is only present at the lowest level for most cases and needs a typo fixing.

build.gradle

@@ -18,7 +18,7 @@ repositories {
 }
 
 archivesBaseName = 'Primitive Collections'
-version = '0.6.0';
+version = '0.7.0';
 
 sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaVersion.current();
 
@@ -44,9 +44,10 @@ configurations {
 }
 
 dependencies {
-	builderImplementation 'de.speiger:Simple-Code-Generator:1.0.7'
+	builderImplementation 'de.speiger:Simple-Code-Generator:1.1.4'
     testImplementation 'junit:junit:4.12'
     testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
+    
 }
 
 task generateSource(type: JavaExec) {
@@ -82,6 +83,8 @@ task srcJar(type: Jar) {
     classifier = 'sources'
 }
 
+compileJava.dependsOn generateGithubSource
+
 javadoc.failOnError = false
 javadoc.options.memberLevel = JavadocMemberLevel.PUBLIC
 javadoc.options.quiet()

features.md

@@ -0,0 +1,402 @@
+## Quality Of Life Features
+New Specialized functions/classes that were added to increase performance and/or reduce allocations and/or for Quality of life.  
+
+
+# Functions
+
+Functions that increase performance or are quality of life in their nature.   
+
+<details>
+<summary>Iterable</summary>
+<p>
+
+## Functional Functions
+
+Java adds themselves a lot of functional functions like,  
+- Stream:
+	- Map/FlatMap
+	- Filter/Distinct/Limit/Sorted
+	- Count/FindFirst/Collect
+	- Peek/ForEach/Reduce
+	- anyMatch/allMatch/NoneMatch   
+
+that allows to process a collection in a functional way.   
+But these require streams which have a lot of Overhead in their nature.    
+
+Luckly Primitive Collections adds replacement functions that provide the same functionality but with minimal overhead.   
+Here are some examples:
+```java
+public ObjectIterable<Path> toPath(ObjectIterable<String> iterable) {
+	return iterable.map(Paths::get).filter(Files::exist);
+}
+
+public Iterable<Path> toPath(Iterable<String> iterable) {
+	return ObjectIterables.map(iterable, Paths::get).filter(Files::exist);
+}
+
+public int sum(IntIterable iterable) {
+	return iterable.reduce(Integer::sum);
+}
+```
+
+## AsyncAPI</summary>
+
+The AsyncAPI is a Feature that simplifies the processing of Collections on a separate thread.   
+It uses the same concept as Javas Stream API but uses the light weight Functions from Primitive Collections to achieve the same thing.   
+Unlike Javas StreamAPI the AsyncAPI is always singleThreaded and more like Javas CompletableFuture, which you can await or let run Asynchronous.    
+
+The Goal is it to simplify the processing of Collections asynchronous.   
+Especially on tasks which don't have to be finished instantly but can be processed on the side.   
+
+Here is a example of how the API works.
+```java
+public void processFiles(ObjectCollection<String> potentialFiles) {
+     potentialFiles.asAsync()
+         .map(Paths::get).filter(Files::exists) //Modifies the collection (Optional)
+         .forEach(Files::delete) //Creates the action (Required)
+         .callback(T -> {}} //Callback on completion, still offthread (Optional)
+         .execute() //Starts the task. (Required)
+}
+```
+</p>
+</details>
+<details>
+<summary>Collection</summary>
+<p>
+
+These are functions specific to the Collections interface, stuff that everyone wished it was present to be in the first place.
+
+## AddAll (Array)
+Adding Elements to a Collection usually requires either a for loop or a Arrays.wrap().   
+This isn't an issue with Primitive Collections.
+```java
+public void addMonths(ObjectCollection<String> months) {
+	months.addAll("January", "February", "March", "April", "May", "June", "July", "August", "September, "October", November", "December");
+}
+
+public void addElements(ObjectCollection<String> result, String[] elements) {
+	result.addAll(elements, 0, 5); //elements, offset, length
+}
+```
+
+## containsAny
+Everyone hates comparing if 2 collections have part of each other included.   
+The solution usually requires for loops and keeping track if things were found or not.   
+And every Java Developer had this issue at least once and wished for a clean solution.
+```java
+public boolean hasMonths(ObjectCollection<Month> target, Collection<Month> toFind) {
+	return target.containsAny(toFind);
+}
+```
+
+## Copy
+Collections get copied every now and then. There is only 2 ways that this happens.  
+Javas Clone API or using Constructor that supports collections.  
+Javas Clone API is kinda in a Zombie state, where it is supported or not. Its not really clear if you should use it or not.  
+The Clone CloneNotSupportedException isn't helping either, causing more janky code.  
+While a Constructor can only support so much and testing for every case isn't really viable.  
+
+So the decision was made to straight out not support clone and instead add a copy function which doesn't use a checked exception.  
+It works exactly like the clone function. In a sense where it creates a shallow copy. (SubCollections do not work for obvious reasons)
+```java
+public IntCollection copy(IntCollection original) {
+	return original.copy();
+}
+```
+
+## Primitive Streams
+Since Javas Stream API is still really useful, even at its shortcomings, Primitive Collections provides easy access to it.  
+Generic Streams and the closest Primitive Stream will be provided. So a FloatCollection goes to a DoubleStream.
+```java
+public IntStream createStream(IntCollection source) {
+	return source.primitiveStream();
+}
+```
+
+## RemoveAll/RetainAll with listener
+Ever wanted use removeAll or retainAll and wanted to know what elements actually got deleted?  
+The usual solution is to create a copy and then apply it to the original and cross reference them.  
+Which leads to really messy code and just hasn't a clean solution.  
+Luckly Primitive Collections got you covered.
+```java
+public void removeInvalidFiles(ObjectCollections<Path> files, ObjectCollection<Path> toRemove) {
+	files.removeAll(toRemove, T -> System.out.println(T));
+}
+
+public void removeInvalidFiles(ObjectCollections<Path> files, ObjectCollection<Path> toKeep) {
+	files.retainFiles(toKeep, T -> System.out.println(T));
+}
+```
+
+## ToArray 
+Primitive Collections supports primitive/generic toArray functions for its Primitive Collections.  
+On top of that the Object side gets a Java9 function ported back to java8, which uses a functional Interface to create the backing array.
+```java
+public Integer[] toArray(IntCollection c) {
+	return c.toArray(new Integer[c.size]);
+}
+
+public int[] toArray(IntCollection c) {
+	return c.toIntArray();
+}
+
+public String[] toArray(ObjectCollection<String> c) {
+	return c.toArray(String::new);
+}
+```
+</p>
+</details>
+
+<details>
+<summary>List</summary>
+<p>
+
+These functions are List specific functions, a couple of these are from FastUtil.
+
+## add/get/remove/extractElements
+These functions really useful helper functions. 3 of which are copied from FastUtil. (extract is from Primitive Collections)  
+They are basically array forms of addAll, getAll, removeRange and removeAndGetRange. This is the simplest way to describe it.  
+
+Here some example:
+```java
+public void addAll(DoubleList list) {
+	list.addElements(0D, 12.2D, 3.5D, 4.2D);
+}
+
+public double[] getAll(DoubleList list, int amount) {
+	double[] result = new double[amount];
+	list.getElements(0, result);
+	return result;
+}
+
+public void removeRange(FloatList list) {
+	list.removeElements(5, 14);
+}
+
+public float[] extractRange(FloatList list) {
+	return list.extractElements(5, 14); //Returns the removed elements
+}
+```
+
+## addIfPresent/addIfAbsent
+These two functions are simple helper functions that check internally if a element is present or absent before adding them to the List.   
+Removing the need for a contains or indexOf check every time you want to add a element.
+While it is of course better to use a set, there is cases where this is still useful.
+
+```java
+public void addElements(IntList list, int... numbersToAdd) {
+	for(int e : numbersToAdd) {
+		list.addIfAbsent(e);
+	}
+}
+
+public void addExisting(ObjectList<String> list, String... textToAdd) {
+	for(String s : textToAdd) {
+		list.addIfPresent(s);
+	}
+}
+```
+
+## SwapRemove
+Lists when removing a Element shift usually the backing array to the left based to shrink the elements.  
+While that isn't computational expensive with LinkedLists, it is with ArrayLists.  
+Here comes swapRemove into play, which just removes the desired elements and instead of shifting left puts the last element in its place.
+This reduces the data copying required down to 1 element instead of an array.
+
+```java
+public int remove(IntList elements, int indexToRemove) {
+	return elements.swapRemove(indexToRemove);
+}
+```
+
+## Unstable Sort (From FastUtil)
+Unstable Sort uses a Faster but not as stable sorting algorithm to sort the Collection.  
+Stable doesn't mean crashing, but more like that the result isn't exactly perfectly sorted.  
+```java
+public void sort(List<Month> list, Comparator<Month> sorter) {
+	list.unstableSort(sorter);
+}
+```
+</p>
+</details>
+
+<details>
+<summary>Map</summary>
+<p>
+
+These functions are based on the Map interface. Useful functions you really would want.  
+
+## addTo/subFrom
+addTo (from FastUtil) and subFrom are mathematically functions that either add or subtract from the value of a given key.   
+And if the key isn't present or would result in the default value it will either add or remove the entry from the Map. Given the circumstance.   
+This is a really useful function and I wish FastUtil made it accessible by default but sadly it isn't.   
+To simplify the explanation:    
+- addTo if no element is present puts in the desired number, otherwise it sums up the two values.   
+- subFrom if a element is present subtracts from it, if the element reaches the default value it removes the element from the map. If not present it will be ignored.   
+```java
+public void addTo(Object2DoubleMap<Month> map, Month key, double averageTrainsRepaired) {
+	map.addTo(key, averageTrainsRepaired);
+}
+
+public void subFrom(Long2IntMap map, long key, double amount) {
+	map.subFrom(key, amount);
+}
+```
+
+## addToAll
+Simple bulk version of the addTo function since sometimes you want to merge 2 maps for summing.  
+Especially if your work is multi-threaded this can become useful.
+
+```java
+public void addTo(Object2DoubleMap<Month> map, Object2DoubleMap<Month> trainsRepaired) {
+	map.addToAll(trainsRepaired);
+}
+```
+
+## mergeAll
+This is a simple bulk version of merge since merging 2 maps is more frequent then people might think and leads to cleaner code too.
+```java
+public void merge(Long2ByteMap result, Long2ByteMap toMerge) {
+	result.mergeAll(toMerge);
+}
+```
+
+## putAll (Array)
+This allows to put keys and values as arrays instead of requiring a WrapperMap to insert the elements.  
+Not as useful as the Collections.addAll variant but still really useful.
+```java
+public void putAll(Int2DoubleMap map, int[] keys, double[] values) {
+	map.put(keys, values, 2, 15);
+}
+```
+
+## putAllIfAbsent
+putAll has this usual quirk where if a element is present it will replace the value, and sometimes this is not wanted.  
+While putIfAbsent exists it has no real mass form and makes iterative solutions really uneasy to use.  
+Here comes the helper function that gets rid of that problem.
+```java
+public void merge(Long2ObjectMap<String> regionFiles, Long2ObjectMap<String> toAdd) {
+	regionFiles.putAllIfAbsent(toAdd);
+}
+```
+
+## removeOrDefault
+getOrDefault is a really useful function that find use cases all the time.   
+Sadly by default there is no variant of removeOrDefault, while it has less cases still could be used every now and then.  
+This function basically tries to remove a element, if it is not present it will just return your desired default.
+```java
+public Path removeCache(Long2ObjectMap<Path> caches, long key) {
+	return caches.removeOrDefault(key, Paths.get("nuclearFun"));
+}
+```
+
+## supplyIfAbsent
+This one is one of my favorites. computeIfAbsent is a really useful function.   
+But in 90% of the cases I use it the value is a collection.  
+This becomes really annoying since methodReferences are faster/cleaner then Lambdas in my opinion.  
+supplyIfAbsent is basically computeIfAbsent but without a key, perfect for the default constructor of a collection.  
+This is the whole reason it exists.  
+```java
+public void example(Int2ObjectMap<List<String>> map, Int2ObjectMap<String> toAdd) {
+	for(Entry<String> entry : toAdd.entrySet()) {
+		map.supplyIfAbsent(entry.getKey(), ObjectArrayList::new).add(entry.getValue());
+	}
+}
+```
+</p>
+</details>
+
+# Interfaces
+
+Interfaces that provide essential or quality of life features.
+
+<details>
+<summary>ITrimmable</summary>
+<p>
+
+The ITrimmable is Accessor interface that allows you to access a couple helper functions to control the size of your collections.  
+This was created for the constant casting requirement to implementations just to shrink collections which get annoying over time.  
+
+## trim
+This function basically trims down the backing implementation to use as little memory as required to store the elements in the collection.  
+Optionally a desired minimum size can be provided as of how low it should go at worst.  
+
+## clearAndTrim
+when you want to reset a Collection completely you have 2 options. Clear it and then call trim, or recreate the collection.  
+clearAndTrim solves this problem by clearing the collection and trimming it in one go, reducing overhead to achieve such a thing.  
+
+</p>
+</details>
+
+<details>
+<summary>IArray</summary>
+<p>
+
+IArray is a Accessor interface that provides more access to collections by providing tools to grow your collection as needed.  
+While putAll/addAll try to ensure that you have enough room for your elements, this is not really a solution for all cases.  
+Sometimes you need to ensure the Collection is pre-initialized.  
+IArray grants you that control.  
+
+There is also a type specific that provides you access to the backing array implementation of Lists for faster Iteration but that is a really specific case.  
+
+## ensureCapacity
+Ensures that your collection has enough storage for the elements you want to insert.  
+
+## elements (ITypeSpecificArray)
+Allows you access to the backing array of a List which is for people who know what they are doing.  
+There is a lambda version of this function too which makes sure for synchronizedLists that you are the only one accessing the array.  
+
+</p>
+</details>
+
+<details>
+<summary>OrderedMap</summary>
+<p>
+
+The OrderedMap is a real edge case interface that was born for a need.    
+FastUtil added functions that were like moveToFirst which were hardcoded to the implementation.  
+They didn't fit into something like a SortedMap because the Set wasn't sorted.  
+So OrderedMap was born, which isn't random but ordered in a specific way that can be changed.  
+
+## getAndMoveToFirst/getAndMoveToLast
+Returns a desired element and removing it to the first/last spot in the Map. Moving the element that was at its spot after/before it.  
+
+## moveToFirst/moveToLast
+Moves the element if present to the first/last spot in the Map. Moving the element that was at its spot after/before it.  
+Returns true if the element was actually moved.  
+
+## putAndMoveToFirst/putAndMoveToLast
+Adds the desired element and moves it to first/last spot in the Map. Moving the element that was at its spot after/before it.  
+
+## firstKey/lastKey (Optional poll)
+Provides access to the current first/last key of the Map.  
+Optionally can be polled if desired.  
+
+## firstValue/lastValue
+Provides access to the current first/last value of the Map.  
+
+</p>
+</details>
+
+<details>
+<summary>OrderedSet</summary>
+<p>
+
+The OrderedSet is a real edge case interface that was born for a need.    
+FastUtil added functions that were like moveToFirst which were hardcoded to the implementation.  
+They didn't fit into something like a SortedSet because the Set wasn't sorted.  
+So OrderedSet was born, which isn't random but ordered in a specific way that can be changed.  
+
+## addAndMoveToFirst/addAndMoveToLast
+Adds the desired element and moves it to first/last spot in the Collection. Moving the element that was at its spot after/before it.  
+
+## moveToFirst/moveToLast
+Moves the element if present to the first/last spot in the Collection. Moving the element that was at its spot after/before it.  
+Returns true if the element was actually moved.  
+
+## first/last (Optional poll)
+Provides access to the current first/last element of the set.  
+Optionally can be polled if desired.
+
+</p>
+</details>

jitpack.yml

@@ -2,6 +2,5 @@ jdk:
    - openjdk9
 install:
    - chmod +x ./gradlew
-   - ./gradlew generateGithubSource
    - ./gradlew build publishToMavenLocal
    

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

@@ -230,6 +230,7 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
 			KEY_TYPE e = iter.NEXT();
 			if(!c.contains(e)) {
+				r.accept(e);
 				iter.remove();
 				modified = true;
 			}
@@ -256,6 +257,7 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 	public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
 		if(a == null || a.length < size()) a = new KEY_TYPE[size()];
 		ITERATORS.unwrap(a, iterator());
+		if (a.length > size()) a[size()] = EMPTY_KEY_VALUE;
 		return a;
 	}
 #endif

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

@@ -57,7 +57,7 @@ public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE
 	public default int back(int amount) {
 		if(amount < 0) throw new IllegalStateException("Can't go forward");
 		int i = 0;
-		for(;i<amount && hasPrevious();previous(),i++);
+		for(;i<amount && hasPrevious();PREVIOUS(),i++);
 		return i;
 	}
 }

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

@@ -5,9 +5,11 @@ import java.util.function.Consumer;
 #if !TYPE_OBJECT
 
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.objects.collections.ObjectIterable;
 #else
 import java.util.function.BiFunction;
+import java.util.Comparator;
 
 #endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
@@ -156,6 +158,15 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 		return ITERABLES.limit(this, limit);
 	}
 	
+	/**
+	 * A Helper function to reduce the usage of Streams and allows to sort the elements
+	 * @param sorter that sorts the elements.
+	 * @return a Iterable that is sorted
+	 */
+	default ITERABLE KEY_GENERIC_TYPE sorted(COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return ITERABLES.sorted(this, sorter);
+	}
+	
 	/**
 	 * A Helper function to reduce the usage of Streams and allows to preview elements before they are iterated through
 	 * @param action the action that should be applied

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

@@ -308,14 +308,14 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		public KEY_TYPE[] getElements(int from, KEY_TYPE[] a, int offset, int length) {
 			SanityChecks.checkArrayCapacity(size, from, length);
 			SanityChecks.checkArrayCapacity(a.length, offset, length);
-			return list.getElements(from+this.offset, a, offset, length);
+			return list.getElements(from+parentOffset, a, offset, length);
 		}
 		
 		@Override
 		public void removeElements(int from, int to) {
 			if(to-from <= 0) return;
 			checkSubRange(from);
-			checkSubRange(to);
+			checkAddSubRange(to);
 			list.removeElements(from+parentOffset, to+parentOffset);
 			size -= to - from;
 		}
@@ -324,9 +324,9 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		@Override
 		public <K> K[] extractElements(int from, int to, Class<K> type) {
 			checkSubRange(from);
-			checkSubRange(to);
+			checkAddSubRange(to);
 			K[] result = list.extractElements(from+parentOffset, to+parentOffset, type);
-			size -= to - from;
+			size -= result.length;
 			return result;
 		}
 
@@ -334,9 +334,9 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		@Override
 		public KEY_TYPE[] extractElements(int from, int to) {
 			checkSubRange(from);
-			checkSubRange(to);
+			checkAddSubRange(to);
 			KEY_TYPE[] result = list.extractElements(from+parentOffset, to+parentOffset);
-			size -= to - from;
+			size -= result.length;
 			return result;
 		}
 		
@@ -344,19 +344,25 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		@Override
 		public KEY_TYPE GET_KEY(int index) {
 			checkSubRange(index);
-			return list.GET_KEY(offset+index);
+			return list.GET_KEY(parentOffset+index);
 		}
 
 		@Override
 		public KEY_TYPE set(int index, KEY_TYPE element) {
 			checkSubRange(index);
-			return list.set(offset+index, element);
+			return list.set(parentOffset+index, element);
 		}
 		
 		@Override
 		public KEY_TYPE swapRemove(int index) {
 			checkSubRange(index);
-			KEY_TYPE result = list.swapRemove(index+parentOffset);
+			if(index == size-1) {
+				KEY_TYPE result = list.REMOVE(parentOffset+size-1);
+				size--;
+				return result;
+			}
+			KEY_TYPE result = list.set(index+parentOffset, list.GET_KEY(parentOffset+size-1));
+			list.REMOVE(parentOffset+size-1);
 			size--;
 			return result;
 		}
@@ -386,7 +392,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		@Override
 		public LIST KEY_GENERIC_TYPE subList(int fromIndex, int toIndex) {
 			SanityChecks.checkArrayCapacity(size, fromIndex, toIndex-fromIndex);
-			return new SubList(list, offset, fromIndex, toIndex);
+			return new SubList(this, offset, fromIndex, toIndex);
 		}
 		
 		protected void checkSubRange(int index) {
@@ -460,15 +466,17 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 			
 			@Override
 			public void add(KEY_TYPE e) {
-				list.add(index++, e);
+				list.add(index, e);
+				index++;
 				lastReturned = -1;
 			}
 			
 			@Override
 			public int skip(int amount) {
 				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-				int steps = Math.min(amount, (list.size() - 1) - index);
+				int steps = Math.min(amount, size() - index);
 				index += steps;
+				if(steps > 0) lastReturned = Math.min(index-1, size()-1);
 				return steps;
 			}
 			
@@ -477,6 +485,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
 				int steps = Math.min(amount, index);
 				index -= steps;
+				if(steps > 0) lastReturned = Math.min(index, size()-1);
 				return steps;
 			}
 		}
@@ -540,15 +549,17 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		
 		@Override
 		public void add(KEY_TYPE e) {
-			ABSTRACT_LIST.this.add(index++, e);
+			ABSTRACT_LIST.this.add(index, e);
+			index++;
 			lastReturned = -1;
 		}
 		
 		@Override
 		public int skip(int amount) {
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			int steps = Math.min(amount, (size() - 1) - index);
+			int steps = Math.min(amount, size() - index);
 			index += steps;
+			if(steps > 0) lastReturned = Math.min(index-1, size()-1);
 			return steps;
 		}
 		
@@ -557,6 +568,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
 			int steps = Math.min(amount, index);
 			index -= steps;
+			if(steps > 0) lastReturned = Math.min(index, size()-1);
 			return steps;
 		}
 	}

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

@@ -86,6 +86,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	 * @param size the minimum initial size of the Backing array
 	 */
 	public ARRAY_LIST(int size) {
+		if(size < 0) throw new IllegalStateException("Size has to be 0 or greater");
 		data = NEW_KEY_ARRAY(size);
 	}
 	
@@ -324,8 +325,9 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	public void addElements(int from, KEY_TYPE[] a, int offset, int length) {
 		if(length <= 0) return;
 		checkAddRange(from);
+		SanityChecks.checkArrayCapacity(a.length, offset, length);
 		grow(size + length);
-		if(from != size) System.arraycopy(data, from, data, from+length, size - length);
+		if(from != size) System.arraycopy(data, from, data, from+length, size - from);
 		size+=length;
 		System.arraycopy(a, offset, data, from, length);
 	}
@@ -361,11 +363,11 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		int length = to - from;
 		if(length <= 0) return;
 		if(to != size) System.arraycopy(data, to, data, from, size - to);
+		size -= length;
 #if TYPE_OBJECT
 		for(int i = 0;i<length;i++)
-			data[i+to] = null;
+			data[i+size] = null;
 #endif
-		size -= length;
 	}
 	
 #if TYPE_OBJECT
@@ -381,13 +383,13 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		checkRange(from);
 		checkAddRange(to);
 		int length = to - from;
+		if(length <= 0) return ARRAYS.newArray(type, 0);
 		K[] a = ARRAYS.newArray(type, length);
-		if(length <= 0) return a;
 		System.arraycopy(data, from, a, 0, length);
 		if(to != size) System.arraycopy(data, to, data, from, size - to);
-		for(int i = 0;i<length;i++)
-			data[i+to] = null;
 		size -= length;
+		for(int i = 0;i<length;i++)
+			data[i+size] = null;
 		return a;
 	}
 	

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

@@ -9,8 +9,9 @@ import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.concurrent.locks.ReentrantLock;
-#if TYPE_OBJECT
 import java.util.function.Consumer;
+import java.util.function.Supplier;
+#if TYPE_OBJECT
 import java.util.function.BiFunction;
 #endif
 import java.util.function.Predicate;
@@ -155,6 +156,14 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	
 #endif
 	
+	private void setArray(KEY_TYPE[] data) {
+		this.data = data;
+	}
+	
+	private KEY_TYPE[] getArray() {
+		return data;
+	}
+	
 	/**
 	 * Appends the specified element to the end of this list.
 	 *
@@ -365,6 +374,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 			KEY_TYPE[] data = this.data;
 			int size = data.length;
 			if(from < 0 || from > size) throw new IndexOutOfBoundsException("Index: " + from + ", Size: " + size);
+			SanityChecks.checkArrayCapacity(a.length, offset, length);
 			KEY_TYPE[] newElements;
 			if(from == size) {
 				newElements = Arrays.copyOf(data, size+length);
@@ -409,6 +419,8 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	 */
 	@Override
 	public void removeElements(int from, int to) {
+		checkRange(from);
+		checkAddRange(to);
 		int length = to - from;
 		if(length <= 0) return;
 		ReentrantLock lock = this.lock;
@@ -439,9 +451,11 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	 */
 	@Override
 	public <K> K[] extractElements(int from, int to, Class<K> type) {
+		checkRange(from);
+		checkAddRange(to);
 		int length = to - from;
+		if(length <= 0) return ARRAYS.newArray(type, 0);
 		K[] a = ARRAYS.newArray(type, length);
-		if(length <= 0) return a;
 		ReentrantLock lock = this.lock;
 		lock.lock();
 		try {
@@ -449,9 +463,9 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 			System.arraycopy(data, from, a, 0, length);
 			if(to == data.length) this.data = Arrays.copyOf(data, data.length - length);
 			else {
-				int size = data.length-1;
+				int size = data.length;
-				KEY_TYPE[] newElements = NEW_KEY_ARRAY(size);
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(size-length);
-				System.arraycopy(data, 0, newElements, 0, from);
+				if(from != 0) System.arraycopy(data, 0, newElements, 0, from);
 				System.arraycopy(data, to, newElements, from, size - to);
 				this.data = newElements;
 			}
@@ -471,6 +485,8 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	 */
 	@Override
 	public KEY_TYPE[] extractElements(int from, int to) {
+		checkRange(from);
+		checkAddRange(to);
 		int length = to - from;
 		if(length <= 0) return EMPTY_KEY_ARRAY;
 		ReentrantLock lock = this.lock;
@@ -481,9 +497,9 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 			System.arraycopy(data, from, a, 0, length);
 			if(to == data.length) this.data = Arrays.copyOf(data, data.length - length);
 			else {
-				int size = data.length-1;
+				int size = data.length;
-				KEY_TYPE[] newElements = NEW_KEY_ARRAY(size);
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(size-length);
-				System.arraycopy(data, 0, newElements, 0, from);
+				if(from != 0) System.arraycopy(data, 0, newElements, 0, from);
 				System.arraycopy(data, to, newElements, from, size - to);
 				this.data = newElements;
 			}
@@ -719,7 +735,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	@Override
 	public LIST KEY_GENERIC_TYPE subList(int fromIndex, int toIndex) {
 		SanityChecks.checkArrayCapacity(data.length, fromIndex, toIndex-fromIndex);
-		return new COWSubListBRACES(this, 0, fromIndex, toIndex);
+		return new COWSubListBRACES(this, lock, this::setArray, this::getArray, 0, fromIndex, toIndex);
 	}
 	
 	/**
@@ -1388,7 +1404,12 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 			throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + data.length);
 	}
 	
-	#if PRIMITIVES
+	protected void checkAddRange(int index) {
+		if (index < 0 || index > data.length)
+			throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + data.length);
+	}
+	
+#if PRIMITIVES
 	/**
 	 * Returns a Java-Type-Specific Stream to reduce boxing/unboxing.
 	 * @return a Stream of the closest java type
@@ -1435,7 +1456,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			return data[index--];
+			return data[--index];
 		}
 		
 		@Override
@@ -1458,7 +1479,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		@Override
 		public int skip(int amount) {
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			int steps = Math.min(amount, (data.length - 1) - index);
+			int steps = Math.min(amount, data.length - index);
 			index += steps;
 			return steps;
 		}
@@ -1474,13 +1495,19 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	
 	private static class COWSubList KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	{
-		final COPY_ON_WRITE_LIST KEY_GENERIC_TYPE list;
+		final ABSTRACT_LIST KEY_GENERIC_TYPE list;
+		final ReentrantLock lock;
+		final Consumer<KEY_TYPE[]> setter;
+		final Supplier<KEY_TYPE[]> getter;
 		final int parentOffset;
 		final int offset;
 		int size;
 		
-		public COWSubList(COPY_ON_WRITE_LIST KEY_GENERIC_TYPE list, int offset, int from, int to) {
+		public COWSubList(ABSTRACT_LIST KEY_GENERIC_TYPE list, ReentrantLock lock, Consumer<KEY_TYPE[]> setter, Supplier<KEY_TYPE[]> getter, int offset, int from, int to) {
 			this.list = list;
+			this.lock = lock;
+			this.setter = setter;
+			this.getter = getter;
 			this.parentOffset = from;
 			this.offset = offset + from;
 			this.size = to - from;
@@ -1488,7 +1515,6 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		
 		@Override
 		public void add(int index, KEY_TYPE element) {
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkAddSubRange(index);
@@ -1504,7 +1530,6 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		public boolean addAll(int index, Collection<? extends CLASS_TYPE> c) {
 			int add = c.size();
 			if(add <= 0) return false;
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkAddSubRange(index);
@@ -1521,7 +1546,6 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		public boolean addAll(int index, COLLECTION KEY_GENERIC_TYPE c) {
 			int add = c.size();
 			if(add <= 0) return false;
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkAddSubRange(index);
@@ -1538,7 +1562,6 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		public boolean addAll(int index, LIST KEY_GENERIC_TYPE c) {
 			int add = c.size();
 			if(add <= 0) return false;
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkAddSubRange(index);
@@ -1554,7 +1577,6 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		@Override
 		public void addElements(int from, KEY_TYPE[] a, int offset, int length) {
 			if(length <= 0) return;
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkAddSubRange(from);
@@ -1570,17 +1592,16 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		public KEY_TYPE[] getElements(int from, KEY_TYPE[] a, int offset, int length) {
 			SanityChecks.checkArrayCapacity(size, from, length);
 			SanityChecks.checkArrayCapacity(a.length, offset, length);
-			return list.getElements(from+this.offset, a, offset, length);
+			return list.getElements(from+parentOffset, a, offset, length);
 		}
 		
 		@Override
 		public void removeElements(int from, int to) {
 			if(to-from <= 0) return;
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkSubRange(from);
-				checkSubRange(to);
+				checkAddSubRange(to);
 				list.removeElements(from+parentOffset, to+parentOffset);
 				size -= to - from;
 			}
@@ -1592,13 +1613,12 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 #if TYPE_OBJECT
 		@Override
 		public <K> K[] extractElements(int from, int to, Class<K> type) {
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkSubRange(from);
-				checkSubRange(to);
+				checkAddSubRange(to);
 				K[] result = list.extractElements(from+parentOffset, to+parentOffset, type);
-				size -= to - from;
+				size -= result.length;
 				return result;
 			}
 			finally {
@@ -1609,13 +1629,12 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 #else
 		@Override
 		public KEY_TYPE[] extractElements(int from, int to) {
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkSubRange(from);
-				checkSubRange(to);
+				checkAddSubRange(to);
 				KEY_TYPE[] result = list.extractElements(from+parentOffset, to+parentOffset);
-				size -= to - from;
+				size -= result.length;
 				return result;
 			}
 			finally {
@@ -1627,16 +1646,15 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		@Override
 		public KEY_TYPE GET_KEY(int index) {
 			checkSubRange(index);
-			return list.GET_KEY(offset+index);
+			return list.GET_KEY(parentOffset+index);
 		}
 
 		@Override
 		public KEY_TYPE set(int index, KEY_TYPE element) {
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkSubRange(index);
-				return list.set(offset+index, element);
+				return list.set(parentOffset+index, element);
 			}
 			finally {
 				lock.unlock();
@@ -1645,11 +1663,18 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		
 		@Override
 		public KEY_TYPE swapRemove(int index) {
-			ReentrantLock lock = list.lock;
+			if(index < 0 || index >= size) throw new IndexOutOfBoundsException();
+			ReentrantLock lock = this.lock;
 			lock.lock();
 			try {
-				checkSubRange(index);
+				KEY_TYPE[] data = getter.get();
-				KEY_TYPE result = list.swapRemove(index+parentOffset);
+				KEY_TYPE result = data[offset+index];
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length-1);
+				int end = offset+size-1;
+				System.arraycopy(data, 0, newElements, 0, end);
+				if(end != newElements.length) System.arraycopy(data, end+1, newElements, end, data.length-end-1);
+				if(index+offset != end) newElements[index+offset] = data[end];
+				setter.accept(newElements);
 				size--;
 				return result;
 			}
@@ -1660,7 +1685,6 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		
 		@Override
 		public KEY_TYPE REMOVE(int index) {
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
 				checkSubRange(index);
@@ -1673,6 +1697,371 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 			}
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public boolean REMOVE_KEY(KEY_TYPE type) {
+			int index = indexOf(type);
+			if(index == -1) return false;
+			REMOVE(index);
+			return true;
+		}
+		
+#else
+		@Override
+		public boolean remove(Object type) {
+			int index = indexOf(type);
+			if(index == -1) return false;
+			REMOVE(index);
+			return true;
+		}
+		
+#endif
+		
+#if TYPE_OBJECT
+		@Override
+		public void sort(Comparator<? super CLASS_TYPE> c) {
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newData = Arrays.copyOf(data, data.length);
+				if(c != null) ARRAYS.stableSort(newData, offset, offset+size, c);
+				else ARRAYS.stableSort(newData, offset, offset+size);
+				setter.accept(newData);
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+		@Override
+		public void unstableSort(Comparator<? super CLASS_TYPE> c) {
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newData = Arrays.copyOf(data, data.length);
+				if(c != null) ARRAYS.unstableSort(newData, offset, offset+size, c);
+				else ARRAYS.unstableSort(newData, offset, offset+size);
+				setter.accept(newData);
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+#else
+		@Override
+		public void sort(COMPARATOR c) {
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newData = Arrays.copyOf(data, data.length);
+				if(c != null) ARRAYS.stableSort(newData, offset, offset+size, c);
+				else ARRAYS.stableSort(newData, offset, offset+size);
+				setter.accept(newData);
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+		@Override
+		public void unstableSort(COMPARATOR c) {
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newData = Arrays.copyOf(data, data.length);
+				if(c != null) ARRAYS.unstableSort(newData, offset, offset+size, c);
+				else ARRAYS.unstableSort(newData, offset, offset+size);
+				setter.accept(newData);
+			}
+			finally {
+				lock.unlock();
+			}	
+		}
+		
+#endif
+		
+		@Override
+		@Deprecated
+		public boolean removeAll(Collection<?> c) {
+			if(c.isEmpty()) return false;
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length);
+				int j = 0;
+				for(int i= 0,m=data.length;i<m;i++) {
+					if(i < offset || i >= offset+size) newElements[j++] = data[i];
+					else if(!c.contains(KEY_TO_OBJ(data[i]))) newElements[j++] = data[i];
+				}
+				if(data.length != j) {
+					setter.accept(Arrays.copyOf(newElements, j));
+					size -= data.length - j;
+					return true;
+				}
+				return false;
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+		@Override
+		@Deprecated
+		public boolean retainAll(Collection<?> c) {
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				if(c.isEmpty()) {
+					if(size > 0) {
+						clear();
+						return true;
+					}
+					return false;
+				}
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length);
+				int j = 0;
+				for(int i= 0,m=data.length;i<m;i++) {
+					if(i < offset || i >= offset+size) newElements[j++] = data[i];
+					else if(c.contains(KEY_TO_OBJ(data[i]))) newElements[j++] = data[i];
+				}
+				if(data.length != j) {
+					setter.accept(Arrays.copyOf(newElements, j));
+					size -= data.length - j;
+					return true;
+				}
+				return false;
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+		@Override
+		@Deprecated
+		public boolean removeIf(Predicate<? super CLASS_TYPE> filter) {
+			Objects.requireNonNull(filter);
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length);
+				int j = 0;
+				for(int i= 0,m=data.length;i<m;i++) {
+					if(i < offset || i >= offset+size) newElements[j++] = data[i];
+					else if(!filter.test(KEY_TO_OBJ(data[i]))) newElements[j++] = data[i];
+				}
+				if(data.length != j) {
+					setter.accept(Arrays.copyOf(newElements, j));
+					size -= data.length - j;
+					return true;
+				}
+				return false;
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+		@Override
+		public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) {
+			if(c.isEmpty()) return false;
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length);
+				int j = 0;
+				for(int i= 0,m=data.length;i<m;i++) {
+					if(i < offset || i >= offset+size) newElements[j++] = data[i];
+					else if(!c.contains(data[i])) newElements[j++] = data[i];
+				}
+				if(data.length != j) {
+					setter.accept(Arrays.copyOf(newElements, j));
+					size -= data.length - j;
+					return true;
+				}
+				return false;
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+		@Override
+		public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+			if(c.isEmpty()) return false;
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length);
+				int j = 0;
+				for(int i= 0,m=data.length;i<m;i++) {
+					if(i < offset || i >= offset+size) newElements[j++] = data[i];
+					else if(!c.contains(data[i])) newElements[j++] = data[i];
+					else r.accept(data[i]);
+				}
+				if(data.length != j) {
+					setter.accept(Arrays.copyOf(newElements, j));
+					size -= data.length - j;
+					return true;
+				}
+				return false;
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+		@Override
+		public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) {
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				if(c.isEmpty()) {
+					if(size > 0) {
+						clear();
+						return true;
+					}
+					return false;
+				}
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length);
+				int j = 0;
+				for(int i= 0,m=data.length;i<m;i++) {
+					if(i < offset || i >= offset+size) newElements[j++] = data[i];
+					else if(c.contains(data[i])) newElements[j++] = data[i];
+				}
+				if(data.length != j) {
+					setter.accept(Arrays.copyOf(newElements, j));;
+					size -= data.length - j;
+					return true;
+				}
+				return false;
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+		@Override
+		public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				if(c.isEmpty()) {
+					if(size > 0) {
+						forEach(r);
+						clear();
+						return true;
+					}
+					return false;
+				}
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length);
+				int j = 0;
+				for(int i= 0,m=data.length;i<m;i++) {
+					if(i < offset || i >= offset+size) newElements[j++] = data[i];
+					else if(c.contains(data[i])) newElements[j++] = data[i];
+					else r.accept(data[i]);
+				}
+				if(data.length != j) {
+					setter.accept(Arrays.copyOf(newElements, j));
+					size -= data.length - j;
+					return true;
+				}
+				return false;
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+#if PRIMITIVES
+		@Override
+		public boolean remIf(JAVA_PREDICATE filter) {
+			Objects.requireNonNull(filter);
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newElements = NEW_KEY_ARRAY(data.length);
+				int j = 0;
+				for(int i=0,m=data.length;i<m;i++) {
+					if(i < offset || i >= offset+size) newElements[j++] = data[i];
+					else if(!filter.test(data[i])) newElements[j++] = data[i];
+				}
+				if(data.length != j) {
+					setter.accept(Arrays.copyOf(newElements, j));
+					size -= data.length - j;
+					return true;
+				}
+				return false;
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+#endif
+		
+		@Override
+		@Primitive
+		public void replaceAll(UnaryOperator<CLASS_TYPE> o) {
+#if PRIMITIVES
+			Objects.requireNonNull(o);
+#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
+			REPLACE(T -> OBJ_TO_KEY(o.apply(KEY_TO_OBJ(SanityChecks.SANITY_CAST(T)))));
+#else
+			REPLACE(T -> OBJ_TO_KEY(o.apply(KEY_TO_OBJ(T))));
+#endif
+#else
+			Objects.requireNonNull(o);
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newData = Arrays.copyOf(data, data.length);
+				for(int i = 0,m=size;i<m;i++)
+					newData[i+offset] = OBJ_TO_KEY(o.apply(KEY_TO_OBJ(newData[i+offset])));
+				setter.accept(newData);
+			}
+			finally {
+				lock.unlock();
+			}
+#endif
+		}
+		
+#if PRIMITIVES
+		@Override
+		public void REPLACE(JAVA_UNARY_OPERATOR o) {
+			Objects.requireNonNull(o);
+			ReentrantLock lock = this.lock;
+			lock.lock();
+			try {
+				KEY_TYPE[] data = getter.get();
+				KEY_TYPE[] newData = Arrays.copyOf(data, data.length);
+				for(int i = 0,m=size;i<m;i++)
+#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
+					newData[i+offset] = SanityChecks.SANITY_CAST(o.APPLY_CAST(newData[i+offset]));
+#else
+					newData[i+offset] = o.APPLY(newData[i+offset]);
+#endif
+				setter.accept(newData);
+			}
+			finally {
+				lock.unlock();
+			}
+		}
+		
+#endif		
 		@Override
 		public int size() {
 			return size;
@@ -1681,10 +2070,9 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		@Override
 		public void clear() {
 			if(size == 0) return;
-			ReentrantLock lock = list.lock;
 			lock.lock();
 			try {
-				list.removeElements(offset, offset+size);
+				list.removeElements(parentOffset, parentOffset+size);
 				size = 0;
 			}
 			finally {
@@ -1704,7 +2092,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		@Override
 		public LIST KEY_GENERIC_TYPE subList(int fromIndex, int toIndex) {
 			SanityChecks.checkArrayCapacity(size, fromIndex, toIndex-fromIndex);
-			return new COWSubListBRACES(list, offset, fromIndex, toIndex);
+			return new COWSubListBRACES(this, lock, setter, getter, offset, fromIndex, toIndex);
 		}
 		
 		protected void checkSubRange(int index) {
@@ -1772,7 +2160,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 		@Override
 		public int skip(int amount) {
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			int steps = Math.min(amount, (list.size() - 1) - index);
+			int steps = Math.min(amount, list.size() - index);
 			index += steps;
 			return steps;
 		}

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

@@ -556,7 +556,7 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 		@Override
 		public int skip(int amount) {
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			int steps = Math.min(amount, (size() - 1) - index);
+			int steps = Math.min(amount, size() - index);
 			index += steps;
 			return steps;
 		}

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

@@ -152,10 +152,16 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		int length = c.size();
 		if(length == 0) return false;
 		checkAddRange(index);
-		Entry KEY_GENERIC_TYPE next = null;
+		Entry KEY_GENERIC_TYPE next;
-		Entry KEY_GENERIC_TYPE prev = null;
+		Entry KEY_GENERIC_TYPE prev;
-		if(index == size) prev = last;
+		if(index == size) {
-		else if(index == 0) next = first;
+			prev = last;
+			next = null;
+		}
+		else if(index == 0) {
+			next = first;
+			prev = null;
+		}
 		else {
 			next = getNode(index);
 			prev = next.prev;
@@ -177,30 +183,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 	@Override
 	public boolean addAll(int index, LIST KEY_GENERIC_TYPE c) {
-		int length = c.size();
+		return addAll(index, (COLLECTION KEY_GENERIC_TYPE)c); //
-		if(length == 0) return false;
-		checkAddRange(index);
-		Entry KEY_GENERIC_TYPE next = null;
-		Entry KEY_GENERIC_TYPE prev = null;
-		if(index == size) prev = last;
-		else if(index == 0) next = first;
-		else {
-			next = getNode(index);
-			prev = next.prev;
-		}
-		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();) {
-			Entry KEY_GENERIC_TYPE entry = new EntryBRACES(iter.NEXT(), prev, null);
-			if(prev == null) first = entry;
-			else prev.next = entry;
-			prev = entry;
-		}
-		if(next == null) last = prev;
-		else {
-			prev.next = next;
-			next.prev = prev;
-		}
-		size += length;
-		return true;
 	}
 	
 	@Override
@@ -210,10 +193,16 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		int length = c.size();
 		if(length == 0) return false;
 		checkAddRange(index);
-		Entry KEY_GENERIC_TYPE next = null;
+		Entry KEY_GENERIC_TYPE next;
-		Entry KEY_GENERIC_TYPE prev = null;
+		Entry KEY_GENERIC_TYPE prev;
-		if(index == size) prev = last;
+		if(index == size) {
-		else if(index == 0) next = first;
+			prev = last;
+			next = null;
+		}
+		else if(index == 0) {
+			next = first;
+			prev = null;
+		}
 		else {
 			next = getNode(index);
 			prev = next.prev;
@@ -258,12 +247,19 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 	@Override
 	public void addElements(int from, KEY_TYPE[] a, int offset, int length) {
+		if(length <= 0) return;
 		SanityChecks.checkArrayCapacity(a.length, offset, length);
 		checkAddRange(from);
-		Entry KEY_GENERIC_TYPE next = null;
+		Entry KEY_GENERIC_TYPE next;
-		Entry KEY_GENERIC_TYPE prev = null;
+		Entry KEY_GENERIC_TYPE prev;
-		if(from == size) prev = last;
+		if(from == size) {
-		else if(from == 0) next = first;
+			prev = last;
+			next = null;
+		}
+		else if(from == 0) {
+			next = first;
+			prev = null;
+		}
 		else {
 			next = getNode(from);
 			prev = next.prev;
@@ -297,13 +293,13 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 	@Override
 	public KEY_TYPE first() {
-		if(first == null) throw new IllegalStateException();
+		if(first == null) throw new NoSuchElementException();
 		return first.value;
 	}
 	
 	@Override
 	public KEY_TYPE last() {
-		if(last == null) throw new IllegalStateException();
+		if(last == null) throw new NoSuchElementException();
 		return last.value;
 	}
 	
@@ -536,13 +532,13 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 	@Override
 	public KEY_TYPE dequeue() {
-		if(first == null) throw new IllegalStateException();
+		if(first == null) throw new NoSuchElementException();
 		return unlinkFirst(first);
 	}
 	
 	@Override
 	public KEY_TYPE dequeueLast() {
-		if(last == null) throw new IllegalStateException();
+		if(last == null) throw new NoSuchElementException();
 		return unlinkLast(last);
 	}
 	
@@ -593,12 +589,15 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			first = temp;
 			return result;
 		}
+		else if(before.next != last) {
 			Entry KEY_GENERIC_TYPE temp = last;
 			last = temp.prev;
 			last.next = null;
 			temp.next = before.next;
 			temp.prev = before;
 			before.next = temp;
+			temp.next.prev = temp;
+		}
 		return result;
 	}
 	
@@ -623,12 +622,15 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 					first = temp;
 					return true;
 				}
+				else if(before.next != last) {
 					Entry KEY_GENERIC_TYPE temp = last;
 					last = temp.prev;
 					last.next = null;
 					temp.next = before.next;
 					temp.prev = before;
 					before.next = temp;
+					temp.next.prev = temp;
+				}
 				return true;
 			}
 		}
@@ -671,16 +673,18 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		if(from < size - to) {
 			Entry KEY_GENERIC_TYPE entry = getNode(from);
 			while(length > 0) {
-				entry = entry.next;
+				Entry KEY_GENERIC_TYPE next = entry.next;
-				unlink(entry.prev);
+				unlink(entry);
+				entry = next;
 				length--;
 			}
 			return;
 		}
-		Entry KEY_GENERIC_TYPE entry = getNode(to);
+		Entry KEY_GENERIC_TYPE entry = getNode(to-1);
 		while(length > 0) {
-			entry = entry.prev;
+			Entry KEY_GENERIC_TYPE prev = entry.prev;
-			unlink(entry.next);
+			unlink(entry);
+			entry = prev;
 			length--;
 		}
 	}
@@ -691,20 +695,22 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		checkRange(from);
 		checkAddRange(to);
 		int length = to - from;
+		if(length <= 0) return ARRAYS.newArray(type, 0);
 		K[] a = ARRAYS.newArray(type, length);
-		if(length <= 0) return a;
 		if(from < size - to) {
 			Entry KEY_GENERIC_TYPE entry = getNode(from);
 			for(int i = 0;length > 0;i++, length--) {
-				entry = entry.next;
+				Entry KEY_GENERIC_TYPE next = entry.next;
-				a[i] = (K)unlink(entry.prev);
+				a[i] = (K)unlink(entry);
+				entry = next;
 			}
 			return a;
 		}
-		Entry KEY_GENERIC_TYPE entry = getNode(to);
+		Entry KEY_GENERIC_TYPE entry = getNode(to-1);
-		for(int i = length-1;length > 0;i--) {
+		for(int i = length-1;length > 0;i--, length--) {
-			entry = entry.prev;
+			Entry KEY_GENERIC_TYPE prev = entry.prev;
-			a[i] = (K)unlink(entry.next);
+			a[i] = (K)unlink(entry);
+			entry = prev;
 		}
 		return a;
 	}
@@ -720,15 +726,17 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		if(from < size - to) {
 			Entry KEY_GENERIC_TYPE entry = getNode(from);
 			for(int i = 0;length > 0;i++, length--) {
-				entry = entry.next;
+				Entry KEY_GENERIC_TYPE next = entry.next;
-				d[i] = unlink(entry.prev);
+				d[i] = unlink(entry);
+				entry = next;
 			}
 			return d;
 		}
-		Entry KEY_GENERIC_TYPE entry = getNode(to);
+		Entry KEY_GENERIC_TYPE entry = getNode(to-1);
-		for(int i = length-1;length > 0;i--) {
+		for(int i = length-1;length > 0;i--, length--) {
-			entry = entry.prev;
+			Entry KEY_GENERIC_TYPE prev = entry.prev;
-			d[i] = unlink(entry.next);
+			d[i] = unlink(entry);
+			entry = prev;
 		}
 		return d;
 	}
@@ -1106,6 +1114,11 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			this.prev = prev;
 			this.next = next;
 		}
+		
+		@Override
+		public String toString() {
+			return KEY_TO_STRING(value);
+		}
 	}
 	
 	private class ListIter implements LIST_ITERATOR KEY_GENERIC_TYPE 
@@ -1239,7 +1252,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		
 		@Override
 		public long estimateSize() {
-			return list.size - index;
+			return (long)list.size - (long)index;
 		}
 		
 		@Override
@@ -1305,7 +1318,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		
 		@Override
 		public long estimateSize() {
-			return list.size - index;
+			return (long)list.size - (long)index;
 		}
 		
 		@Override

src/builder/resources/speiger/assets/collections/templates/maps/abstracts/AbstractMap.template

@@ -285,6 +285,16 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 	}
 	
 #endif
+	
+	@Override
+	public CLASS_VALUE_TYPE remove(Object key) {
+#if TYPE_OBJECT
+		return VALUE_TO_OBJ(REMOVE_VALUE((CLASS_TYPE)key));
+#else
+		return key instanceof CLASS_TYPE ? VALUE_TO_OBJ(REMOVE_VALUE(CLASS_TO_KEY(key))) : VALUE_TO_OBJ(getDefaultReturnValue());
+#endif
+	}
+	
 	@Override
 	public void forEach(BI_CONSUMER KEY_VALUE_GENERIC_TYPE action) {
 		Objects.requireNonNull(action);
@@ -306,7 +316,11 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 #else
 			@Override
 			public boolean remove(Object o) {
-				return VALUE_EQUALS_NOT(ABSTRACT_MAP.this.remove(o), getDefaultReturnValue());
+				if(ABSTRACT_MAP.this.containsKey(o)) {
+					ABSTRACT_MAP.this.remove(o);
+					return true;
+				}
+				return false;
 			}
 			
 #endif

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

@@ -73,6 +73,7 @@ import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 import speiger.src.collections.utils.HashUtil;
+import speiger.src.collections.utils.ITrimmable;
 
 /**
  * A TypeSpecific ConcurrentHashMap implementation that is based on <a href="https://github.com/google/guava">Guavas</a> approach and backing array implementations.
@@ -84,7 +85,7 @@ import speiger.src.collections.utils.HashUtil;
  * @Type(T)
  * @ValueType(V)
  */
-public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE
+public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE, ITrimmable
 {
 	/** Segment Limit */
 	private static final int MAX_SEGMENTS = 1 << 16;
@@ -538,6 +539,30 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		}
 	}
 	
+	@Override
+	public boolean trim(int size) {
+		int segmentCapacity = size / segments.length;
+		if(segmentCapacity * segments.length < size) {
+			segmentCapacity++;
+		}
+		boolean result = false;
+		for(int i = 0, m=segments.length;i<m;i++) {
+			result |= segments[i].trim(segmentCapacity);
+		}
+		return result;
+	}
+	
+	@Override
+	public void clearAndTrim(int size) {
+		int segmentCapacity = size / segments.length;
+		if(segmentCapacity * segments.length < size) {
+			segmentCapacity++;
+		}
+		for(int i = 0, m=segments.length;i<m;i++) {
+			segments[i].clearAndTrim(segmentCapacity);
+		}
+	}
+	
 	@Override
 	public boolean isEmpty() {
 		for(int i = 0,m=segments.length;i<m;i++) {
@@ -2025,7 +2050,11 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 			long stamp = writeLock();
 			try
 			{
+#if TYPE_OBJECT
 				if(key == null) {
+#else
+				if(key == null || (key instanceof CLASS_TYPE && KEY_EQUALS_NULL(CLASS_TO_KEY(key)))) {
+#endif
 					if(containsNull && EQUALS_VALUE_TYPE(values[nullIndex], value)) {
 						removeNullIndex();
 						return true;
@@ -2202,7 +2231,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		
 		protected boolean trim(int size) {
 			int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-			if(request >= size || this.size > Math.min((int)Math.ceil(request * loadFactor), request - 1)) return false;
+			if(request >= mask+1 || this.size > Math.min((int)Math.ceil(request * loadFactor), request - 1)) return false;
 			long stamp = writeLock();
 			try {
 				try {
@@ -2218,7 +2247,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		
 		protected void clearAndTrim(int size) {
 			int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-			if(request >= size) {
+			if(request >= mask+1) {
 				clear();
 				return;
 			}
@@ -2298,6 +2327,9 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 #endif
 		protected int findIndex(int hash, Object key) {
 			if(key == null) return containsNull ? nullIndex : -(nullIndex + 1);
+#if !TYPE_OBJECT
+			if(KEY_EQUALS_NULL(CLASS_TO_KEY(key))) return containsNull ? nullIndex : -(nullIndex + 1);
+#endif
 			int pos = hash & mask;
 			KEY_TYPE current = keys[pos];
 			if(KEY_EQUALS_NOT_NULL(current)) {

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

@@ -22,7 +22,6 @@ import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
-import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.PACKAGE.utils.STRATEGY;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -57,7 +56,7 @@ 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.ObjectSet;
+import speiger.src.collections.objects.sets.ObjectOrderedSet;
 #endif
 import speiger.src.collections.utils.HashUtil;
 
@@ -285,7 +284,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	
 	@Override
 	public boolean moveToFirst(KEY_TYPE key) {
-		if(strategy.equals(FIRST_ENTRY_KEY(), key)) return false;
+		if(isEmpty() || strategy.equals(FIRST_ENTRY_KEY(), key)) return false;
 		if(strategy.equals(key, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
 				moveToFirstIndex(nullIndex);
@@ -307,7 +306,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	
 	@Override
 	public boolean moveToLast(KEY_TYPE key) {
-		if(strategy.equals(LAST_ENTRY_KEY(), key)) return false;
+		if(isEmpty() || strategy.equals(LAST_ENTRY_KEY(), key)) return false;
 		if(strategy.equals(key, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
 				moveToLastIndex(nullIndex);
@@ -370,8 +369,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	public KEY_TYPE POLL_FIRST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = firstIndex;
-		firstIndex = (int)links[pos];
+		onNodeRemoved(pos);
-		if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L;
 		KEY_TYPE result = keys[pos];
 		size--;
 		if(strategy.equals(result, EMPTY_KEY_VALUE)) {
@@ -394,8 +392,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	public KEY_TYPE POLL_LAST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = lastIndex;
-		lastIndex = (int)(links[pos] >>> 32);
+		onNodeRemoved(pos);
-		if(0 <= lastIndex) links[lastIndex] |= 0xFFFFFFFFL;
 		KEY_TYPE result = keys[pos];
 		size--;
 		if(strategy.equals(result, EMPTY_KEY_VALUE)) {
@@ -421,15 +418,15 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	}
 	
 	@Override
-	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
+	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
-		return entrySet;
+		return (ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySet;
 	}
 	
 	@Override
-	public SET KEY_GENERIC_TYPE keySet() {
+	public ORDERED_SET KEY_GENERIC_TYPE keySet() {
 		if(keySet == null) keySet = new KeySet();
-		return keySet;
+		return (ORDERED_SET KEY_GENERIC_TYPE)keySet;
 	}
 	
 	@Override
@@ -456,7 +453,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	@Override
 	public void clearAndTrim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size) {
+		if(request >= nullIndex) {
 			clear();
 			return;
 		}

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

@@ -394,7 +394,11 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	@Override
 	public boolean remove(Object key, Object value) {
 		Objects.requireNonNull(value);
+#if TYPE_OBJECT
 		if(key == null) {
+#else
+		if(key == null || (key instanceof CLASS_TYPE && strategy.equals(CLASS_TO_KEY(key), EMPTY_KEY_VALUE))) {
+#endif
 			if(containsNull && EQUALS_VALUE_TYPE(values[nullIndex], value)) {
 				removeNullIndex();
 				return true;
@@ -628,7 +632,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	@Override
 	public boolean trim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size || this.size > Math.min((int)Math.ceil(request * loadFactor), request - 1)) return false;
+		if(request >= nullIndex || this.size > Math.min((int)Math.ceil(request * loadFactor), request - 1)) return false;
 		try {
 			rehash(request);
 		}
@@ -639,7 +643,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	@Override
 	public void clearAndTrim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size) {
+		if(request >= nullIndex) {
 			clear();
 			return;
 		}
@@ -669,6 +673,9 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	protected int findIndex(CLASS_TYPE key) {
 		if(key == null) return containsNull ? nullIndex : -(nullIndex + 1);
 		KEY_TYPE keyType = CLASS_TO_KEY(key);
+#if !TYPE_OBJECT
+		if(strategy.equals(keyType, EMPTY_KEY_VALUE)) return containsNull ? nullIndex : -(nullIndex + 1);
+#endif
 		int pos = HashUtil.mix(strategy.hashCode(keyType)) & mask;
 		KEY_TYPE current = keys[pos];
 		if(!strategy.equals(current, EMPTY_KEY_VALUE)) {
@@ -942,7 +949,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				state = new BasicEntryKV_BRACES(keys[nullIndex], values[nullIndex]);
 				empty = false;
 			}
-			for(int i = 0;i<size;i++) {
+			for(int i = nullIndex-1;i>=0;i--) {
 				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
 				if(empty) {
 					empty = false;
@@ -1173,7 +1180,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				state = keys[nullIndex];
 				empty = false;
 			}
-			for(int i = 0;i<size;i++) {
+			for(int i = nullIndex-1;i>=0;i--) {
 				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
 				if(empty) {
 					empty = false;
@@ -1329,7 +1336,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				state = values[nullIndex];
 				empty = false;
 			}
-			for(int i = 0;i<size;i++) {
+			for(int i = nullIndex-1;i>=0;i--) {
 				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
 				if(empty) {
 					empty = false;

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

@@ -22,7 +22,6 @@ import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
-import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
@@ -56,7 +55,7 @@ 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.ObjectSet;
+import speiger.src.collections.objects.sets.ObjectOrderedSet;
 #endif
 import speiger.src.collections.utils.HashUtil;
 
@@ -262,7 +261,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	
 	@Override
 	public boolean moveToFirst(KEY_TYPE key) {
-		if(KEY_EQUALS(FIRST_ENTRY_KEY(), key)) return false;
+		if(isEmpty() || KEY_EQUALS(FIRST_ENTRY_KEY(), key)) return false;
 		if(KEY_EQUALS_NULL(key)) {
 			if(containsNull) {
 				moveToFirstIndex(nullIndex);
@@ -284,7 +283,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	
 	@Override
 	public boolean moveToLast(KEY_TYPE key) {
-		if(KEY_EQUALS(LAST_ENTRY_KEY(), key)) return false;
+		if(isEmpty() || KEY_EQUALS(LAST_ENTRY_KEY(), key)) return false;
 		if(KEY_EQUALS_NULL(key)) {
 			if(containsNull) {
 				moveToLastIndex(nullIndex);
@@ -374,8 +373,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	public KEY_TYPE POLL_FIRST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = firstIndex;
-		firstIndex = (int)links[pos];
+		onNodeRemoved(pos);
-		if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L;
 		KEY_TYPE result = keys[pos];
 		size--;
 		if(KEY_EQUALS_NULL(result)) {
@@ -398,8 +396,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	public KEY_TYPE POLL_LAST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = lastIndex;
-		lastIndex = (int)(links[pos] >>> 32);
+		onNodeRemoved(pos);
-		if(0 <= lastIndex) links[lastIndex] |= 0xFFFFFFFFL;
 		KEY_TYPE result = keys[pos];
 		size--;
 		if(KEY_EQUALS_NULL(result)) {
@@ -425,15 +422,15 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	}
 	
 	@Override
-	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
+	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
-		return entrySet;
+		return (ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySet;
 	}
 	
 	@Override
-	public SET KEY_GENERIC_TYPE keySet() {
+	public ORDERED_SET KEY_GENERIC_TYPE keySet() {
 		if(keySet == null) keySet = new KeySet();
-		return keySet;
+		return (ORDERED_SET KEY_GENERIC_TYPE)keySet;
 	}
 	
 	@Override
@@ -460,7 +457,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	@Override
 	public void clearAndTrim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size) {
+		if(request >= nullIndex) {
 			clear();
 			return;
 		}

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

@@ -362,7 +362,11 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	@Override
 	public boolean remove(Object key, Object value) {
 		Objects.requireNonNull(value);
+#if TYPE_OBJECT
 		if(key == null) {
+#else
+		if(key == null || (key instanceof CLASS_TYPE && KEY_EQUALS_NULL(CLASS_TO_KEY(key)))) {
+#endif
 			if(containsNull && EQUALS_VALUE_TYPE(values[nullIndex], value)) {
 				removeNullIndex();
 				return true;
@@ -589,7 +593,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	@Override
 	public boolean trim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size || this.size > Math.min((int)Math.ceil(request * loadFactor), request - 1)) return false;
+		if(request >= nullIndex || this.size >= Math.min((int)Math.ceil(request * loadFactor), request - 1)) return false;
 		try {
 			rehash(request);
 		}
@@ -600,7 +604,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	@Override
 	public void clearAndTrim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size) {
+		if(request >= nullIndex) {
 			clear();
 			return;
 		}
@@ -629,6 +633,9 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 #endif
 	protected int findIndex(Object key) {
 		if(key == null) return containsNull ? nullIndex : -(nullIndex + 1);
+#if !TYPE_OBJECT
+		if(key instanceof CLASS_TYPE && KEY_EQUALS_NULL(CLASS_TO_KEY(key))) return containsNull ? nullIndex : -(nullIndex + 1);
+#endif
 		int pos = HashUtil.mix(key.hashCode()) & mask;
 		KEY_TYPE current = keys[pos];
 		if(KEY_EQUALS_NOT_NULL(current)) {
@@ -902,7 +909,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				state = new BasicEntryKV_BRACES(keys[nullIndex], values[nullIndex]);
 				empty = false;
 			}
-			for(int i = 0;i<size;i++) {
+			for(int i = nullIndex-1;i>=0;i--) {
 				if(KEY_EQUALS_NULL(keys[i])) continue;
 				if(empty) {
 					empty = false;
@@ -1129,7 +1136,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				state = keys[nullIndex];
 				empty = false;
 			}
-			for(int i = 0;i<size;i++) {
+			for(int i = nullIndex-1;i>=0;i--) {
 				if(KEY_EQUALS_NULL(keys[i])) continue;
 				if(empty) {
 					empty = false;
@@ -1285,7 +1292,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				state = values[nullIndex];
 				empty = false;
 			}
-			for(int i = 0;i<size;i++) {
+			for(int i = nullIndex-1;i>=0;i--) {
 				if(KEY_EQUALS_NULL(keys[i])) continue;
 				if(empty) {
 					empty = false;

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

@@ -25,7 +25,9 @@ import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 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;
+#if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
+#endif
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
@@ -47,7 +49,6 @@ import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
 #endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
-import speiger.src.collections.PACKAGE.sets.SET;
 #endif
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -70,7 +71,7 @@ import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOpera
 import speiger.src.collections.objects.lists.ObjectListIterator;
 #endif
 import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectSet;
+import speiger.src.collections.objects.sets.ObjectOrderedSet;
 import speiger.src.collections.utils.HashUtil;
 import speiger.src.collections.utils.SanityChecks;
 
@@ -100,9 +101,9 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	/** The Last Index in the Map */
 	protected int lastIndex = -1;
 	/** EntrySet cache */
-	protected transient FastEntrySet KEY_VALUE_GENERIC_TYPE entrySet;
+	protected transient FastOrderedSet KEY_VALUE_GENERIC_TYPE entrySet;
 	/** KeySet cache */
-	protected transient SET KEY_GENERIC_TYPE keySet;
+	protected transient ORDERED_SET KEY_GENERIC_TYPE keySet;
 	/** Values cache */
 	protected transient VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC;
 	
@@ -429,13 +430,13 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	}	
 
 	@Override
-	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
+	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
 		return entrySet;
 	}
 	
 	@Override
-	public SET KEY_GENERIC_TYPE keySet() {
+	public ORDERED_SET KEY_GENERIC_TYPE keySet() {
 		if(keySet == null) keySet = new KeySet();
 		return keySet;
 	}
@@ -516,6 +517,9 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 #endif
 	protected int findIndex(Object key) {
 		if(key == null) return containsNull ? nullIndex : -(nullIndex + 1);
+#if !TYPE_OBJECT
+		if(KEY_EQUALS_NULL(CLASS_TO_KEY(key))) return containsNull ? nullIndex : -(nullIndex + 1);
+#endif
 		int pos = HashUtil.mix(key.hashCode()) & mask;
 		KEY_TYPE current = keys[pos];
 		if(KEY_EQUALS_NOT_NULL(current)) {

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

@@ -27,7 +27,6 @@ import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
-import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -90,7 +89,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	/** Amount of Elements stored in the ArrayMap */
 	protected int size = 0;
 	/** KeySet cache */
-	protected SET KEY_GENERIC_TYPE keySet;
+	protected ORDERED_SET KEY_GENERIC_TYPE keySet;
 	/** Values cache */
 	protected VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC;
 	/** EntrySet cache */
@@ -270,7 +269,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	@Override
 	public boolean moveToLast(KEY_TYPE key) {
 		int index = findIndex(key);
-		if(index < size-1) {
+		if(index >= 0 && index < size-1) {
 			moveIndexToLast(index);
 			return true;
 		}
@@ -437,7 +436,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	}
 	
 	@Override
-	public SET KEY_GENERIC_TYPE keySet() {
+	public ORDERED_SET KEY_GENERIC_TYPE keySet() {
 		if(keySet == null) keySet = new KeySet();
 		return keySet;
 	}
@@ -1234,6 +1233,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		public EntryIterator() {}
 		public EntryIterator(KEY_TYPE from) {
 			index = findIndex(from);
+			if(index == -1) throw new NoSuchElementException();
 		}
 		
 		@Override
@@ -1249,8 +1249,10 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Override
 		public void remove() {
 			super.remove();
+			if(entry != null && entry.index != -1) {
 				entry.index = -1;				
 			}
+		}
 		
 		@Override
 		public void set(MAP.Entry KEY_VALUE_GENERIC_TYPE e) { throw new UnsupportedOperationException(); }
@@ -1262,7 +1264,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		public KeyIterator() {}
 		public KeyIterator(KEY_TYPE element) {
 			index = findIndex(element);
+			if(index == -1) throw new NoSuchElementException();
 		}
+		
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			return keys[previousEntry()];
@@ -1319,8 +1323,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		}
 		
 		public void remove() {
-			if(lastReturned == -1)
+			if(lastReturned == -1) throw new IllegalStateException();
-				throw new IllegalStateException();
 			removeIndex(lastReturned);
 			if(lastReturned < index)
 				index--;
@@ -1329,8 +1332,8 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 		public int previousEntry() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			lastReturned = index;
+			index--;
-			return index--;
+			return (lastReturned = index);
 		}
 		
 		public int nextEntry() {
@@ -1341,8 +1344,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 		public int skip(int amount) {
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			int steps = Math.min(amount, (size() - 1) - index);
+			int steps = Math.min(amount, size() - index);
 			index += steps;
+			if(steps > 0) lastReturned = Math.min(index-1, size()-1);
 			return steps;
 		}
 		
@@ -1350,6 +1354,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
 			int steps = Math.min(amount, index);
 			index -= steps;
+			if(steps > 0) lastReturned = Math.min(index, size()-1);
 			return steps;
 		}
 	}

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

@@ -4,6 +4,7 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.function.Consumer;
 
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -76,8 +77,8 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 		if(keys.length != values.length) throw new IllegalArgumentException("Keys and Values have to be the same size");
 		keyType = keys[0].getDeclaringClass();
 		this.keys = getKeyUniverse(keyType);
-		this.values = NEW_VALUE_ARRAY(keys.length);
+		this.values = NEW_VALUE_ARRAY(this.keys.length);
-		present = new long[((keys.length - 1) >> 6) + 1];
+		present = new long[((this.keys.length - 1) >> 6) + 1];
 		putAll(keys, values);
 	}
 	
@@ -93,8 +94,8 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 		if(keys.length != values.length) throw new IllegalArgumentException("Keys and Values have to be the same size");
 		keyType = keys[0].getDeclaringClass();
 		this.keys = getKeyUniverse(keyType);
-		this.values = NEW_VALUE_ARRAY(keys.length);
+		this.values = NEW_VALUE_ARRAY(this.keys.length);
-		present = new long[((keys.length - 1) >> 6) + 1];
+		present = new long[((this.keys.length - 1) >> 6) + 1];
 		putAll(keys, values);		
 	}
 	
@@ -530,6 +531,14 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 			return false;
 		}
 		
+		@Override
+		public void forEach(Consumer<? super MAP.Entry KEY_VALUE_GENERIC_TYPE> action) {
+			if(size() <= 0) return;
+			for(int i = 0,m=keys.length;i<m;i++) {
+				if(isSet(i)) action.accept(new BasicEntryKV_BRACES(keys[i], values[i]));
+			}
+		}
+		
 		@Override
 		public ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
 			return new EntryIterator();

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

@@ -17,7 +17,6 @@ import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
-import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
@@ -29,7 +28,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.ObjectSet;
 #endif
 
 /**
@@ -68,9 +66,9 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		if(keys.length != values.length) throw new IllegalArgumentException("Keys and Values have to be the same size");
 		keyType = keys[0].getDeclaringClass();
 		this.keys = getKeyUniverse(keyType);
-		this.values = NEW_VALUE_ARRAY(keys.length);
+		this.values = NEW_VALUE_ARRAY(this.keys.length);
-		present = new long[((keys.length - 1) >> 6) + 1];
+		present = new long[((this.keys.length - 1) >> 6) + 1];
-		links = new long[keys.length];
+		links = new long[this.keys.length];
 		putAll(keys, values);
 	}
 	
@@ -86,9 +84,9 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		if(keys.length != values.length) throw new IllegalArgumentException("Keys and Values have to be the same size");
 		keyType = keys[0].getDeclaringClass();
 		this.keys = getKeyUniverse(keyType);
-		this.values = NEW_VALUE_ARRAY(keys.length);
+		this.values = NEW_VALUE_ARRAY(this.keys.length);
-		present = new long[((keys.length - 1) >> 6) + 1];
+		present = new long[((this.keys.length - 1) >> 6) + 1];
-		links = new long[keys.length];
+		links = new long[this.keys.length];
 		putAll(keys, values);		
 	}
 	
@@ -241,7 +239,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	@Override
 	public VALUE_TYPE getAndMoveToFirst(T key) {
 		int index = key.ordinal();
-		if(index < 0) return getDefaultReturnValue();
+		if(!isSet(index)) return getDefaultReturnValue();
 		moveToFirstIndex(index);
 		return values[index];
 	}
@@ -249,7 +247,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	@Override
 	public VALUE_TYPE getAndMoveToLast(T key) {
 		int index = key.ordinal();
-		if(index < 0) return getDefaultReturnValue();
+		if(!isSet(index)) return getDefaultReturnValue();
 		moveToLastIndex(index);
 		return values[index];
 	}
@@ -315,15 +313,15 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	}
 	
 	@Override
-	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
+	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
-		return entrySet;
+		return (ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySet;
 	}
 	
 	@Override
-	public SET KEY_GENERIC_TYPE keySet() {
+	public ORDERED_SET KEY_GENERIC_TYPE keySet() {
 		if(keySet == null) keySet = new KeySet();
-		return keySet;
+		return (ORDERED_SET KEY_GENERIC_TYPE)keySet;
 	}
 	
 	@Override
@@ -830,6 +828,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 			previous = from.ordinal() - 1;
 			index = from.ordinal();
 			next = from.ordinal();
+			if(!isSet(index)) throw new NoSuchElementException();
 		}
 		
 		public boolean hasNext() {

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

@@ -30,8 +30,9 @@ import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+#if TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+#endif
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -408,7 +409,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	
 	@Override
 	public KEY_TYPE POLL_FIRST_ENTRY_KEY() {
-		if(tree == null) return EMPTY_KEY_VALUE;
+		if(tree == null) return getDefaultMinValue();
 		KEY_TYPE result = first.key;
 		removeNode(first);
 		return result;
@@ -422,7 +423,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	
 	@Override
 	public KEY_TYPE POLL_LAST_ENTRY_KEY() {
-		if(tree == null) return EMPTY_KEY_VALUE;
+		if(tree == null) return getDefaultMaxValue();
 		KEY_TYPE result = last.key;
 		removeNode(last);
 		return result;
@@ -682,7 +683,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	}
 	
 	@Override
-	public SORTED_SET KEY_GENERIC_TYPE keySet() {
+	public NAVIGABLE_SET KEY_GENERIC_TYPE keySet() {
 		return navigableKeySet();
 	}
 	
@@ -1022,6 +1023,33 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		public KEY_TYPE ceiling(KEY_TYPE e) { return map.ceilingKey(e); }
 		@Override
 		public KEY_TYPE higher(KEY_TYPE e) { return map.higherKey(e); }
+		
+#if !TYPE_OBJECT
+		@Override
+		public CLASS_TYPE lower(CLASS_TYPE e) {
+			MAP.Entry KEY_VALUE_GENERIC_TYPE node = map.lowerEntry(OBJ_TO_KEY(e));
+			return node != null ? node.getKey() : null;
+		}
+		
+		@Override
+		public CLASS_TYPE floor(CLASS_TYPE e) {
+			MAP.Entry KEY_VALUE_GENERIC_TYPE node = map.floorEntry(OBJ_TO_KEY(e));
+			return node != null ? node.getKey() : null;
+		}
+		
+		@Override
+		public CLASS_TYPE higher(CLASS_TYPE e) {
+			MAP.Entry KEY_VALUE_GENERIC_TYPE node = map.higherEntry(OBJ_TO_KEY(e));
+			return node != null ? node.getKey() : null;
+		}
+		
+		@Override
+		public CLASS_TYPE ceiling(CLASS_TYPE e) {
+			MAP.Entry KEY_VALUE_GENERIC_TYPE node = map.ceilingEntry(OBJ_TO_KEY(e));
+			return node != null ? node.getKey() : null;
+		}
+		
+#endif
 		@Override
 		public KEY_TYPE POLL_FIRST_KEY() { return map.POLL_FIRST_ENTRY_KEY(); }
 		@Override
@@ -1447,7 +1475,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		}
 		
 		@Override
-		public SET KEY_GENERIC_TYPE keySet() {
+		public NAVIGABLE_SET KEY_GENERIC_TYPE keySet() {
 			return navigableKeySet();
 		}
 		
@@ -1461,8 +1489,8 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		protected abstract BI_ITERATOR KEY_GENERIC_TYPE keyIterator(KEY_TYPE element);
 		protected abstract VALUE_BI_ITERATOR VALUE_GENERIC_TYPE valueIterator();
 		protected abstract BI_ITERATOR KEY_GENERIC_TYPE descendingKeyIterator();
-		protected KEY_TYPE lowKeyOrNull(Node KEY_VALUE_GENERIC_TYPE entry) { return entry == null ? EMPTY_KEY_VALUE : entry.key; }
+		protected KEY_TYPE lowKeyOrNull(Node KEY_VALUE_GENERIC_TYPE entry) { return entry == null ? getDefaultMinValue() : entry.key; }
-		protected KEY_TYPE highKeyOrNull(Node KEY_VALUE_GENERIC_TYPE entry) { return entry == null ? EMPTY_KEY_VALUE : entry.key; }
+		protected KEY_TYPE highKeyOrNull(Node KEY_VALUE_GENERIC_TYPE entry) { return entry == null ? getDefaultMaxValue() : entry.key; }
 		protected Node KEY_VALUE_GENERIC_TYPE next(Node KEY_VALUE_GENERIC_TYPE entry) { return entry.next(); }
 		protected Node KEY_VALUE_GENERIC_TYPE previous(Node KEY_VALUE_GENERIC_TYPE entry) { return entry.previous(); }
 		
@@ -1533,7 +1561,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				map.removeNode(entry);
 				return result;
 			}
-			return EMPTY_KEY_VALUE;
+			return getDefaultMinValue();
 		}
 		
 		@Override
@@ -1544,19 +1572,21 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				map.removeNode(entry);
 				return result;
 			}
-			return EMPTY_KEY_VALUE;
+			return getDefaultMaxValue();
 		}
 		
 		@Override
 		public VALUE_TYPE FIRST_ENTRY_VALUE() {
 			Node KEY_VALUE_GENERIC_TYPE entry = subLowest();
-			return entry == null ? map.getDefaultReturnValue() : entry.value;
+			if(entry == null) throw new NoSuchElementException();
+			return entry.value;
 		}
 		
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() {
 			Node KEY_VALUE_GENERIC_TYPE entry = subHighest();
-			return entry == null ? map.getDefaultReturnValue() : entry.value;
+			if(entry == null) throw new NoSuchElementException();
+			return entry.value;
 		}
 		
 		@Override
@@ -1632,7 +1662,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		
 		@Override
 		public VALUE_TYPE REMOVE_VALUEOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) {
-			return inRange(key) ? map.REMOVE_VALUE(key) : defaultValue;
+			return inRange(key) ? map.REMOVE_VALUEOrDefault(key, defaultValue) : defaultValue;
 		}
 		
 #if TYPE_OBJECT && VALUE_OBJECT
@@ -1778,7 +1808,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 					KEY_TYPE key = entry.ENTRY_KEY();
 					if (!inRange(key)) return false;
 					Node KEY_VALUE_GENERIC_TYPE node = map.findNode(key);
-					if (node != null && VALUE_EQUALS(node.getValue(), entry.getValue())) {
+					if (node != null && VALUE_EQUALS(node.ENTRY_VALUE(), entry.ENTRY_VALUE())) {
 						map.removeNode(node);
 						return true;
 					}
@@ -2023,26 +2053,36 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		class DecsendingSubEntryIterator extends SubMapEntryIterator implements ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE>
 		{
 			public DecsendingSubEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, false);
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.previous();
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.next();
 			}
 			
 			@Override
 			public MAP.Entry KEY_VALUE_GENERIC_TYPE previous() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				return nextEntry();
+				return previousEntry();
 			}
 
 			@Override
 			public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
 				if(!hasNext()) throw new NoSuchElementException();
-				return previousEntry();
+				return nextEntry();
 			}
 		}
 		
 		class AcsendingSubEntryIterator extends SubMapEntryIterator implements ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE>
 		{
 			public AcsendingSubEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, true);
 			}
 
 			@Override
@@ -2061,26 +2101,36 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		class DecsendingSubKeyIterator extends SubMapEntryIterator implements BI_ITERATOR KEY_GENERIC_TYPE
 		{
 			public DecsendingSubKeyIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, false);
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.previous();
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.next();
 			}
 			
 			@Override
 			public KEY_TYPE PREVIOUS() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				return nextEntry().key;
+				return previousEntry().key;
 			}
 
 			@Override
 			public KEY_TYPE NEXT() {
 				if(!hasNext()) throw new NoSuchElementException();
-				return previousEntry().key;
+				return nextEntry().key;
 			}
 		}
 		
 		class AcsendingSubKeyIterator extends SubMapEntryIterator implements BI_ITERATOR KEY_GENERIC_TYPE
 		{
 			public AcsendingSubKeyIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, true);
 			}
 
 			@Override
@@ -2099,7 +2149,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		class AcsendingSubValueIterator extends SubMapEntryIterator implements VALUE_BI_ITERATOR VALUE_GENERIC_TYPE
 		{
 			public AcsendingSubValueIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, true);
 			}
 
 			@Override
@@ -2118,39 +2168,60 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		class DecsendingSubValueIterator extends SubMapEntryIterator implements VALUE_BI_ITERATOR VALUE_GENERIC_TYPE
 		{
 			public DecsendingSubValueIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, false);
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.previous();
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.next();
 			}
 			
 			@Override
 			public VALUE_TYPE VALUE_PREVIOUS() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				return nextEntry().value;
+				return previousEntry().value;
 			}
 
 			@Override
 			public VALUE_TYPE VALUE_NEXT() {
 				if(!hasNext()) throw new NoSuchElementException();
-				return previousEntry().value;
+				return nextEntry().value;
 			}
 		}
 		
 		abstract class SubMapEntryIterator
 		{
+			final boolean isForward;
 			boolean wasForward;
 			Node KEY_VALUE_GENERIC_TYPE lastReturned;
 			Node KEY_VALUE_GENERIC_TYPE next;
+			Node KEY_VALUE_GENERIC_TYPE previous;
 			boolean unboundForwardFence;
 			boolean unboundBackwardFence;
 			KEY_TYPE forwardFence;
 			KEY_TYPE backwardFence;
 			
-			public SubMapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence)
+			public SubMapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence, boolean isForward) {
-			{
 				next = first;
-				this.forwardFence = forwardFence == null ? null : forwardFence.key;
+				previous = first == null ? null : movePrevious(first);
-				this.backwardFence = backwardFence == null ? null : backwardFence.key;
+				this.forwardFence = forwardFence == null ? EMPTY_KEY_VALUE : forwardFence.key;
+				this.backwardFence = backwardFence == null ? EMPTY_KEY_VALUE : backwardFence.key;
 				unboundForwardFence = forwardFence == null;
 				unboundBackwardFence = backwardFence == null;
+				this.isForward = isForward;
+			}
+			
+			protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.next();
+			}
+			
+			protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.previous();
 			}
 			
 			public boolean hasNext() {
@@ -2159,26 +2230,30 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			
 			protected Node KEY_VALUE_GENERIC_TYPE nextEntry() {
 				lastReturned = next;
+				previous = next;
 				Node KEY_VALUE_GENERIC_TYPE result = next;
-				next = next.next();
+				next = moveNext(next);
-				wasForward = true;
+				wasForward = isForward;
 				return result;
 			}
 			
 			public boolean hasPrevious() {
-                return next != null && (unboundBackwardFence || next.key != backwardFence);
+                return previous != null && (unboundBackwardFence || previous.key != backwardFence);
 			}
 			
 			protected Node KEY_VALUE_GENERIC_TYPE previousEntry() {
-				lastReturned = next;
+				lastReturned = previous;
-				Node KEY_VALUE_GENERIC_TYPE result = next;
+				next = previous;
-				next = next.previous();
+				Node KEY_VALUE_GENERIC_TYPE result = previous;
-				wasForward = false;
+				previous = movePrevious(previous);
+				wasForward = !isForward;
 				return result;
 			}
 			
 			public void remove() {
 				if(lastReturned == null) throw new IllegalStateException();
+				if(next == lastReturned) next = moveNext(next);
+				if(previous == lastReturned) previous = movePrevious(previous);
 				if(wasForward && lastReturned.needsSuccessor()) next = lastReturned;
 				map.removeNode(lastReturned);
 				lastReturned = null;
@@ -2492,19 +2567,29 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	class DescendingKeyIterator extends MapEntryIterator implements BI_ITERATOR KEY_GENERIC_TYPE
 	{
 		public DescendingKeyIterator(Node KEY_VALUE_GENERIC_TYPE first) {
-			super(first);
+			super(first, false);
+		}
+		
+		@Override
+		protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+			return node.previous();
+		}
+		
+		@Override
+		protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+			return node.next();
 		}
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			return nextEntry().key;
+			return previousEntry().key;
 		}
 
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			return previousEntry().key;
+			return nextEntry().key;
 		}
 	}
 	
@@ -2512,7 +2597,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	{
 		public AscendingMapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first)
 		{
-			super(first);
+			super(first, true);
 		}
 
 		@Override
@@ -2531,7 +2616,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	class AscendingValueIterator extends MapEntryIterator implements VALUE_BI_ITERATOR VALUE_GENERIC_TYPE
 	{
 		public AscendingValueIterator(Node KEY_VALUE_GENERIC_TYPE first) {
-			super(first);
+			super(first, true);
 		}
 
 		@Override
@@ -2550,7 +2635,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	class AscendingKeyIterator extends MapEntryIterator implements BI_ITERATOR KEY_GENERIC_TYPE
 	{
 		public AscendingKeyIterator(Node KEY_VALUE_GENERIC_TYPE first) {
-			super(first);
+			super(first, true);
 		}
 
 		@Override
@@ -2568,13 +2653,24 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	
 	abstract class MapEntryIterator
 	{
+		final boolean isForward;
 		boolean wasMoved = false;
 		Node KEY_VALUE_GENERIC_TYPE lastReturned;
 		Node KEY_VALUE_GENERIC_TYPE next;
+		Node KEY_VALUE_GENERIC_TYPE previous;
 		
-		public MapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first)
+		public MapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, boolean isForward) {
-		{
 			next = first;
+			previous = first == null ? null : movePrevious(first);
+			this.isForward = isForward;
+		}
+		
+		protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+			return node.next();
+		}
+		
+		protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+			return node.previous();
 		}
 		
 		public boolean hasNext() {
@@ -2583,26 +2679,30 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		
 		protected Node KEY_VALUE_GENERIC_TYPE nextEntry() {
 			lastReturned = next;
+			previous = next;
 			Node KEY_VALUE_GENERIC_TYPE result = next;
-			next = next.next();
+			next = moveNext(next);
-			wasMoved = true;
+			wasMoved = isForward;
 			return result;
 		}
 		
 		public boolean hasPrevious() {
-            return next != null;
+            return previous != null;
 		}
 		
 		protected Node KEY_VALUE_GENERIC_TYPE previousEntry() {
-			lastReturned = next;
+			lastReturned = previous;
-			Node KEY_VALUE_GENERIC_TYPE result = next;
+			next = previous;
-			next = next.previous();
+			Node KEY_VALUE_GENERIC_TYPE result = previous;
-			wasMoved = false;
+			previous = movePrevious(previous);
+			wasMoved = !isForward;
 			return result;
 		}
 		
 		public void remove() {
 			if(lastReturned == null) throw new IllegalStateException();
+			if(next == lastReturned) next = moveNext(next);
+			if(previous == lastReturned) previous = movePrevious(previous);
 			if(wasMoved && lastReturned.needsSuccessor()) next = lastReturned;
 			removeNode(lastReturned);
 			lastReturned = null;

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

@@ -30,8 +30,9 @@ import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+#if TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+#endif
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -411,7 +412,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	
 	@Override
 	public KEY_TYPE POLL_FIRST_ENTRY_KEY() {
-		if(tree == null) return EMPTY_KEY_VALUE;
+		if(tree == null) return getDefaultMinValue();
 		KEY_TYPE result = first.key;
 		removeNode(first);
 		return result;
@@ -425,7 +426,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	
 	@Override
 	public KEY_TYPE POLL_LAST_ENTRY_KEY() {
-		if(tree == null) return EMPTY_KEY_VALUE;
+		if(tree == null) return getDefaultMaxValue();
 		KEY_TYPE result = last.key;
 		removeNode(last);
 		return result;
@@ -685,7 +686,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	}
 	
 	@Override
-	public SORTED_SET KEY_GENERIC_TYPE keySet() {
+	public NAVIGABLE_SET KEY_GENERIC_TYPE keySet() {
 		return navigableKeySet();
 	}
 	
@@ -1080,6 +1081,33 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		public KEY_TYPE ceiling(KEY_TYPE e) { return map.ceilingKey(e); }
 		@Override
 		public KEY_TYPE higher(KEY_TYPE e) { return map.higherKey(e); }
+		
+#if !TYPE_OBJECT
+		@Override
+		public CLASS_TYPE lower(CLASS_TYPE e) {
+			MAP.Entry KEY_VALUE_GENERIC_TYPE node = map.lowerEntry(OBJ_TO_KEY(e));
+			return node != null ? node.getKey() : null;
+		}
+		
+		@Override
+		public CLASS_TYPE floor(CLASS_TYPE e) {
+			MAP.Entry KEY_VALUE_GENERIC_TYPE node = map.floorEntry(OBJ_TO_KEY(e));
+			return node != null ? node.getKey() : null;
+		}
+		
+		@Override
+		public CLASS_TYPE higher(CLASS_TYPE e) {
+			MAP.Entry KEY_VALUE_GENERIC_TYPE node = map.higherEntry(OBJ_TO_KEY(e));
+			return node != null ? node.getKey() : null;
+		}
+		
+		@Override
+		public CLASS_TYPE ceiling(CLASS_TYPE e) {
+			MAP.Entry KEY_VALUE_GENERIC_TYPE node = map.ceilingEntry(OBJ_TO_KEY(e));
+			return node != null ? node.getKey() : null;
+		}
+		
+#endif
 		@Override
 		public KEY_TYPE POLL_FIRST_KEY() { return map.POLL_FIRST_ENTRY_KEY(); }
 		@Override
@@ -1283,6 +1311,11 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			return keySet;
 		}
 		
+		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE keySet() {
+			return navigableKeySet();
+		}
+		
 		@Override
 		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, boolean fromInclusive, KEY_TYPE toKey, boolean toInclusive) {
 			if (!inRange(fromKey, fromInclusive)) throw new IllegalArgumentException("fromKey out of range");
@@ -1369,6 +1402,11 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			return keySet;
 		}
 		
+		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE keySet() {
+			return navigableKeySet();
+		}
+		
 		@Override
 		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, boolean fromInclusive, KEY_TYPE toKey, boolean toInclusive) {
 			if (!inRange(fromKey, fromInclusive)) throw new IllegalArgumentException("fromKey out of range");
@@ -1504,7 +1542,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		}
 		
 		@Override
-		public SET KEY_GENERIC_TYPE keySet() {
+		public NAVIGABLE_SET KEY_GENERIC_TYPE keySet() {
 			return navigableKeySet();
 		}
 		
@@ -1518,8 +1556,8 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		protected abstract BI_ITERATOR KEY_GENERIC_TYPE keyIterator(KEY_TYPE element);
 		protected abstract VALUE_BI_ITERATOR VALUE_GENERIC_TYPE valueIterator();
 		protected abstract BI_ITERATOR KEY_GENERIC_TYPE descendingKeyIterator();
-		protected KEY_TYPE lowKeyOrNull(Node KEY_VALUE_GENERIC_TYPE entry) { return entry == null ? EMPTY_KEY_VALUE : entry.key; }
+		protected KEY_TYPE lowKeyOrNull(Node KEY_VALUE_GENERIC_TYPE entry) { return entry == null ? getDefaultMinValue() : entry.key; }
-		protected KEY_TYPE highKeyOrNull(Node KEY_VALUE_GENERIC_TYPE entry) { return entry == null ? EMPTY_KEY_VALUE : entry.key; }
+		protected KEY_TYPE highKeyOrNull(Node KEY_VALUE_GENERIC_TYPE entry) { return entry == null ? getDefaultMaxValue() : entry.key; }
 		protected Node KEY_VALUE_GENERIC_TYPE next(Node KEY_VALUE_GENERIC_TYPE entry) { return entry.next(); }
 		protected Node KEY_VALUE_GENERIC_TYPE previous(Node KEY_VALUE_GENERIC_TYPE entry) { return entry.previous(); }
 		
@@ -1590,7 +1628,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				map.removeNode(entry);
 				return result;
 			}
-			return EMPTY_KEY_VALUE;
+			return getDefaultMinValue();
 		}
 		
 		@Override
@@ -1601,19 +1639,21 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				map.removeNode(entry);
 				return result;
 			}
-			return EMPTY_KEY_VALUE;
+			return getDefaultMaxValue();
 		}
 		
 		@Override
 		public VALUE_TYPE FIRST_ENTRY_VALUE() {
 			Node KEY_VALUE_GENERIC_TYPE entry = subLowest();
-			return entry == null ? map.getDefaultReturnValue() : entry.value;
+			if(entry == null) throw new NoSuchElementException();
+			return entry.value;
 		}
 		
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() {
 			Node KEY_VALUE_GENERIC_TYPE entry = subHighest();
-			return entry == null ? map.getDefaultReturnValue() : entry.value;
+			if(entry == null) throw new NoSuchElementException();
+			return entry.value;
 		}
 		
 		@Override
@@ -1689,7 +1729,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		
 		@Override
 		public VALUE_TYPE REMOVE_VALUEOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) {
-			return inRange(key) ? map.REMOVE_VALUE(key) : defaultValue;
+			return inRange(key) ? map.REMOVE_VALUEOrDefault(key, defaultValue) : defaultValue;
 		}
 		
 #if TYPE_OBJECT && VALUE_OBJECT
@@ -1835,7 +1875,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 					KEY_TYPE key = entry.ENTRY_KEY();
 					if (!inRange(key)) return false;
 					Node KEY_VALUE_GENERIC_TYPE node = map.findNode(key);
-					if (node != null && VALUE_EQUALS(node.getValue(), entry.getValue())) {
+					if (node != null && VALUE_EQUALS(node.ENTRY_VALUE(), entry.ENTRY_VALUE())) {
 						map.removeNode(node);
 						return true;
 					}
@@ -2080,26 +2120,36 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		class DecsendingSubEntryIterator extends SubMapEntryIterator implements ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE>
 		{
 			public DecsendingSubEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, false);
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.previous();
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.next();
 			}
 			
 			@Override
 			public MAP.Entry KEY_VALUE_GENERIC_TYPE previous() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				return nextEntry();
+				return previousEntry();
 			}
 
 			@Override
 			public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
 				if(!hasNext()) throw new NoSuchElementException();
-				return previousEntry();
+				return nextEntry();
 			}
 		}
 		
 		class AcsendingSubEntryIterator extends SubMapEntryIterator implements ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE>
 		{
 			public AcsendingSubEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, true);
 			}
 
 			@Override
@@ -2118,26 +2168,36 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		class DecsendingSubKeyIterator extends SubMapEntryIterator implements BI_ITERATOR KEY_GENERIC_TYPE
 		{
 			public DecsendingSubKeyIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, false);
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.previous();
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.next();
 			}
 			
 			@Override
 			public KEY_TYPE PREVIOUS() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				return nextEntry().key;
+				return previousEntry().key;
 			}
 
 			@Override
 			public KEY_TYPE NEXT() {
 				if(!hasNext()) throw new NoSuchElementException();
-				return previousEntry().key;
+				return nextEntry().key;
 			}
 		}
 		
 		class AcsendingSubKeyIterator extends SubMapEntryIterator implements BI_ITERATOR KEY_GENERIC_TYPE
 		{
 			public AcsendingSubKeyIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, true);
 			}
 
 			@Override
@@ -2156,7 +2216,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		class AcsendingSubValueIterator extends SubMapEntryIterator implements VALUE_BI_ITERATOR VALUE_GENERIC_TYPE
 		{
 			public AcsendingSubValueIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, true);
 			}
 
 			@Override
@@ -2175,39 +2235,60 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		class DecsendingSubValueIterator extends SubMapEntryIterator implements VALUE_BI_ITERATOR VALUE_GENERIC_TYPE
 		{
 			public DecsendingSubValueIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence) {
-				super(first, forwardFence, backwardFence);
+				super(first, forwardFence, backwardFence, false);
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.previous();
+			}
+			
+			@Override
+			protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.next();
 			}
 			
 			@Override
 			public VALUE_TYPE VALUE_PREVIOUS() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				return nextEntry().value;
+				return previousEntry().value;
 			}
 
 			@Override
 			public VALUE_TYPE VALUE_NEXT() {
 				if(!hasNext()) throw new NoSuchElementException();
-				return previousEntry().value;
+				return nextEntry().value;
 			}
 		}
 		
 		abstract class SubMapEntryIterator
 		{
+			final boolean isForward;
 			boolean wasForward;
 			Node KEY_VALUE_GENERIC_TYPE lastReturned;
 			Node KEY_VALUE_GENERIC_TYPE next;
+			Node KEY_VALUE_GENERIC_TYPE previous;
 			boolean unboundForwardFence;
 			boolean unboundBackwardFence;
 			KEY_TYPE forwardFence;
 			KEY_TYPE backwardFence;
 			
-			public SubMapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence)
+			public SubMapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, Node KEY_VALUE_GENERIC_TYPE forwardFence, Node KEY_VALUE_GENERIC_TYPE backwardFence, boolean isForward) {
-			{
 				next = first;
-				this.forwardFence = forwardFence == null ? null : forwardFence.key;
+				previous = first == null ? null : movePrevious(first);
-				this.backwardFence = backwardFence == null ? null : backwardFence.key;
+				this.forwardFence = forwardFence == null ? EMPTY_KEY_VALUE : forwardFence.key;
+				this.backwardFence = backwardFence == null ? EMPTY_KEY_VALUE : backwardFence.key;
 				unboundForwardFence = forwardFence == null;
 				unboundBackwardFence = backwardFence == null;
+				this.isForward = isForward;
+			}
+			
+			protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.next();
+			}
+			
+			protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+				return node.previous();
 			}
 			
 			public boolean hasNext() {
@@ -2216,26 +2297,30 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			
 			protected Node KEY_VALUE_GENERIC_TYPE nextEntry() {
 				lastReturned = next;
+				previous = next;
 				Node KEY_VALUE_GENERIC_TYPE result = next;
-				next = next.next();
+				next = moveNext(next);
-				wasForward = true;
+				wasForward = isForward;
 				return result;
 			}
 			
 			public boolean hasPrevious() {
-                return next != null && (unboundBackwardFence || next.key != backwardFence);
+                return previous != null && (unboundBackwardFence || previous.key != backwardFence);
 			}
 			
 			protected Node KEY_VALUE_GENERIC_TYPE previousEntry() {
-				lastReturned = next;
+				lastReturned = previous;
-				Node KEY_VALUE_GENERIC_TYPE result = next;
+				next = previous;
-				next = next.previous();
+				Node KEY_VALUE_GENERIC_TYPE result = previous;
-				wasForward = false;
+				previous = movePrevious(previous);
+				wasForward = !isForward;
 				return result;
 			}
 			
 			public void remove() {
 				if(lastReturned == null) throw new IllegalStateException();
+				if(next == lastReturned) next = moveNext(next);
+				if(previous == lastReturned) previous = movePrevious(previous);
 				if(wasForward && lastReturned.needsSuccessor()) next = lastReturned;
 				map.removeNode(lastReturned);
 				lastReturned = null;
@@ -2549,19 +2634,29 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	class DescendingKeyIterator extends MapEntryIterator implements BI_ITERATOR KEY_GENERIC_TYPE
 	{
 		public DescendingKeyIterator(Node KEY_VALUE_GENERIC_TYPE first) {
-			super(first);
+			super(first, false);
+		}
+		
+		@Override
+		protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+			return node.previous();
+		}
+		
+		@Override
+		protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+			return node.next();
 		}
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			return nextEntry().key;
+			return previousEntry().key;
 		}
 
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			return previousEntry().key;
+			return nextEntry().key;
 		}
 	}
 	
@@ -2569,7 +2664,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	{
 		public AscendingMapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first)
 		{
-			super(first);
+			super(first, true);
 		}
 
 		@Override
@@ -2588,7 +2683,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	class AscendingValueIterator extends MapEntryIterator implements VALUE_BI_ITERATOR VALUE_GENERIC_TYPE
 	{
 		public AscendingValueIterator(Node KEY_VALUE_GENERIC_TYPE first) {
-			super(first);
+			super(first, true);
 		}
 
 		@Override
@@ -2607,7 +2702,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	class AscendingKeyIterator extends MapEntryIterator implements BI_ITERATOR KEY_GENERIC_TYPE
 	{
 		public AscendingKeyIterator(Node KEY_VALUE_GENERIC_TYPE first) {
-			super(first);
+			super(first, true);
 		}
 
 		@Override
@@ -2625,13 +2720,24 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	
 	abstract class MapEntryIterator
 	{
+		final boolean isForward;
 		boolean wasMoved = false;
 		Node KEY_VALUE_GENERIC_TYPE lastReturned;
 		Node KEY_VALUE_GENERIC_TYPE next;
+		Node KEY_VALUE_GENERIC_TYPE previous;
 		
-		public MapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first)
+		public MapEntryIterator(Node KEY_VALUE_GENERIC_TYPE first, boolean isForward) {
-		{
 			next = first;
+			previous = first == null ? null : movePrevious(first);
+			this.isForward = isForward;
+		}
+		
+		protected Node KEY_VALUE_GENERIC_TYPE moveNext(Node KEY_VALUE_GENERIC_TYPE node) {
+			return node.next();
+		}
+		
+		protected Node KEY_VALUE_GENERIC_TYPE movePrevious(Node KEY_VALUE_GENERIC_TYPE node) {
+			return node.previous();
 		}
 		
 		public boolean hasNext() {
@@ -2640,26 +2746,30 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		
 		protected Node KEY_VALUE_GENERIC_TYPE nextEntry() {
 			lastReturned = next;
+			previous = next;
 			Node KEY_VALUE_GENERIC_TYPE result = next;
-			next = next.next();
+			next = moveNext(next);
-			wasMoved = true;
+			wasMoved = isForward;
 			return result;
 		}
 		
 		public boolean hasPrevious() {
-            return next != null;
+            return previous != null;
 		}
 		
 		protected Node KEY_VALUE_GENERIC_TYPE previousEntry() {
-			lastReturned = next;
+			lastReturned = previous;
-			Node KEY_VALUE_GENERIC_TYPE result = next;
+			next = previous;
-			next = next.previous();
+			Node KEY_VALUE_GENERIC_TYPE result = previous;
-			wasMoved = false;
+			previous = movePrevious(previous);
+			wasMoved = !isForward;
 			return result;
 		}
 		
 		public void remove() {
 			if(lastReturned == null) throw new IllegalStateException();
+			if(next == lastReturned) next = moveNext(next);
+			if(previous == lastReturned) previous = movePrevious(previous);
 			if(wasMoved && lastReturned.needsSuccessor()) next = lastReturned;
 			removeNode(lastReturned);
 			lastReturned = null;

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

@@ -557,8 +557,8 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 		 */
 		public KEY_TYPE ENTRY_KEY();
 		public default CLASS_TYPE getKey() { return KEY_TO_OBJ(ENTRY_KEY()); }
-#endif
 		
+#endif
 #if !VALUE_OBJECT
 		/**
 		 * Type Specific getValue method that reduces boxing/unboxing
@@ -1381,6 +1381,7 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 		 * @param initialSize the requested start capacity
 		 */
 		public BuilderCache(int initialSize) {
+			if(initialSize < 0) throw new IllegalStateException("Minimum Capacity is negative. This is not allowed");
 			keys = NEW_KEY_ARRAY(initialSize);
 			values = NEW_VALUE_ARRAY(initialSize);
 		}

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

@@ -34,7 +34,9 @@ public interface NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE extends SORTED_MAP KEY_VAL
 	/** @return a Type Specific pollLastEntry */
 	@Override
 	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry();
-	
+	/** @return a Type Specific Navigable Key Set */
+	@Override
+	public NAVIGABLE_SET KEY_GENERIC_TYPE keySet();
 	/**
 	 * Creates a Wrapped NavigableMap that is Synchronized
 	 * @return a new NavigableMap that is synchronized

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

@@ -1,6 +1,9 @@
 package speiger.src.collections.PACKAGE.maps.interfaces;
 
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
+#endif
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.sets.ObjectOrderedSet;
 /**
@@ -94,6 +97,10 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	
 	@Override
 	public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy();
+	@Override
+	public ORDERED_SET KEY_GENERIC_TYPE keySet();
+	@Override
+	public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET();
 	
 	/**
 	 * Creates a Wrapped SortedMap that is Synchronized

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

@@ -9,9 +9,11 @@ import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
-import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
+#if !TYPE_OBJECT
 import speiger.src.collections.objects.sets.ObjectSortedSet;
+#endif
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 
 /**
@@ -31,7 +33,7 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	public SORTED_MAP KEY_VALUE_GENERIC_TYPE copy();
 	
 	@Override
-	public SET KEY_GENERIC_TYPE keySet();
+	public SORTED_SET KEY_GENERIC_TYPE keySet();
 	@Override
 	public VALUE_COLLECTION VALUE_GENERIC_TYPE values();
 	
@@ -155,11 +157,11 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	public VALUE_TYPE LAST_ENTRY_VALUE();
 	
 	@Override
-	public default SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, CLASS_TYPE toKey) { return subMap(OBJ_TO_KEY(fromKey), OBJ_TO_KEY(toKey)); }
+	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, CLASS_TYPE toKey);
 	@Override
-	public default SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(CLASS_TYPE toKey) { return headMap(OBJ_TO_KEY(toKey)); }
+	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(CLASS_TYPE toKey);
 	@Override
-	public default SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey) { return tailMap(OBJ_TO_KEY(fromKey)); }
+	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey);
 #endif
 	
 	/**

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

@@ -106,11 +106,16 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	
 	@Override
 	public void clear() {
+		if(first != last) {
 #if TYPE_OBJECT
 			Arrays.fill(array, null);
 #endif
 			first = last = 0;
 		}
+		else if(first != 0) {
+			first = last = 0;
+		}
+	}
 	
 	@Override
 	public void enqueue(KEY_TYPE e) {
@@ -152,9 +157,9 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	
 	@Override
 	public KEY_TYPE peek(int index) {
-		if(first == last || index < 0 || index > size()) throw new NoSuchElementException();
+		if(first == last || index < 0 || index >= size()) throw new NoSuchElementException();
 		index += first;
-		return index > array.length ? array[index-array.length] : array[index];
+		return index >= array.length ? array[index-array.length] : array[index];
 	}
 	
 	@Override
@@ -429,6 +434,7 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 
 		@Override
 		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
 			KEY_TYPE value = array[index];
 			removeIndex(index);
 			index = ++index % array.length;

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

@@ -187,7 +187,7 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 	
 	@Override
 	public void enqueue(KEY_TYPE e) {
-		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (array.length >> 1), SanityChecks.MAX_ARRAY_SIZE), size+1));
+		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (long)(array.length >> 1), (long)SanityChecks.MAX_ARRAY_SIZE), size+1));
 		if(firstIndex != -1){
 			int compare = comparator == null ? COMPAREABLE_TO_KEY(e, array[firstIndex]) : comparator.compare(e, array[firstIndex]);
 			if(compare < 0) firstIndex = size;
@@ -414,6 +414,7 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 		
 		@Override
 		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
 			return dequeue();
 		}
 	}

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

@@ -207,7 +207,7 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 	
 	@Override
 	public void enqueue(KEY_TYPE e) {
-		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (array.length >> 1), SanityChecks.MAX_ARRAY_SIZE), size+1));
+		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (long)(array.length >> 1), (long)SanityChecks.MAX_ARRAY_SIZE), size+1));
 		array[size++] = e;
 		ARRAYS.shiftUp(array, size-1, comparator);
 	}
@@ -389,6 +389,7 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 		
 		@Override
 		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
 			return dequeue();
 		}
 	}

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

@@ -888,15 +888,11 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }
 		
-		public KEY_TYPE getDefaultMaxValue() { return super.getDefaultMinValue(); }
-		
-		public KEY_TYPE getDefaultMinValue() { return super.getDefaultMaxValue(); }
-		
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) {
 			if(!inRange(fromElement, fromInclusive)) throw new IllegalArgumentException("fromElement out of range");
 			if(!inRange(toElement, toInclusive)) throw new IllegalArgumentException("toElement out of range");
-			return new DescendingSubSetBRACES(set, false, fromElement, fromInclusive, false, toElement, toInclusive);
+			return new DescendingSubSetBRACES(set, false, toElement, toInclusive, false, fromElement, fromInclusive);
 		}
 		
 		@Override
@@ -973,21 +969,15 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 #if !TYPE_OBJECT
 		@Override
 		public void setDefaultMaxValue(KEY_TYPE value) { set.setDefaultMaxValue(value); }
-		
 		@Override
 		public KEY_TYPE getDefaultMaxValue() { return set.getDefaultMaxValue(); }
-		
 		@Override
 		public void setDefaultMinValue(KEY_TYPE value) { set.setDefaultMinValue(value); }
-		
 		@Override
 		public KEY_TYPE getDefaultMinValue() { return set.getDefaultMinValue(); }
-		
 #else
 		public KEY_TYPE getDefaultMaxValue() { return null; }
-		
 		public KEY_TYPE getDefaultMinValue() { return null; }
-		
 #endif
 		@Override
 		public abstract	BI_ITERATOR KEY_GENERIC_TYPE iterator();
@@ -1298,6 +1288,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		{
 			Entry KEY_GENERIC_TYPE lastReturned;
 			Entry KEY_GENERIC_TYPE next;
+			Entry KEY_GENERIC_TYPE previous;
 			boolean forwards = false;
 			boolean unboundForwardFence;
 			boolean unboundBackwardFence;
@@ -1307,6 +1298,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			public AscendingSubSetIterator(Entry KEY_GENERIC_TYPE first, Entry KEY_GENERIC_TYPE forwardFence, Entry KEY_GENERIC_TYPE backwardFence)
 			{
 				next = first;
+				previous = first == null ? null : first.previous();
 				this.forwardFence = forwardFence == null ? EMPTY_KEY_VALUE : forwardFence.key;
 				this.backwardFence = backwardFence == null ? EMPTY_KEY_VALUE : backwardFence.key;
 				unboundForwardFence = forwardFence == null;
@@ -1322,6 +1314,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			public KEY_TYPE NEXT() {
 				if(!hasNext()) throw new NoSuchElementException();
 				lastReturned = next;
+				previous = next;
 				KEY_TYPE result = next.key;
 				next = next.next();
 				forwards = true;
@@ -1330,15 +1323,16 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			
 			@Override
 			public boolean hasPrevious() {
-                return next != null && (unboundBackwardFence || next.key != backwardFence);
+                return previous != null && (unboundBackwardFence || previous.key != backwardFence);
 			}
 			
 			@Override
 			public KEY_TYPE PREVIOUS() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				lastReturned = next;
+				lastReturned = previous;
-				KEY_TYPE result = next.key;
+				next = previous;
-				next = next.previous();
+				KEY_TYPE result = previous.key;
+				previous = previous.previous();
 				forwards = false;
 				return result;
 			}
@@ -1346,6 +1340,8 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			@Override
 			public void remove() {
 				if(lastReturned == null) throw new IllegalStateException();
+				if(previous == lastReturned) previous = previous.previous();
+				if(next == lastReturned) next = next.next();
 				if(forwards && lastReturned.needsSuccessor()) next = lastReturned;
 				set.removeNode(lastReturned);
 				lastReturned = null;
@@ -1356,6 +1352,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		{
 			Entry KEY_GENERIC_TYPE lastReturned;
 			Entry KEY_GENERIC_TYPE next;
+			Entry KEY_GENERIC_TYPE previous;
 			boolean forwards = false;
 			boolean unboundForwardFence;
 			boolean unboundBackwardFence;
@@ -1365,6 +1362,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			public DescendingSubSetIterator(Entry KEY_GENERIC_TYPE first, Entry KEY_GENERIC_TYPE forwardFence, Entry KEY_GENERIC_TYPE backwardFence)
 			{
 				next = first;
+				previous = first == null ? null : first.next();
 				this.forwardFence = forwardFence == null ? EMPTY_KEY_VALUE : forwardFence.key;
 				this.backwardFence = backwardFence == null ? EMPTY_KEY_VALUE : backwardFence.key;
 				unboundForwardFence = forwardFence == null;
@@ -1380,6 +1378,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			public KEY_TYPE NEXT() {
 				if(!hasNext()) throw new NoSuchElementException();
 				lastReturned = next;
+				previous = next;
 				KEY_TYPE result = next.key;
 				next = next.previous();
 				forwards = false;
@@ -1388,15 +1387,16 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			
 			@Override
 			public boolean hasPrevious() {
-                return next != null && (unboundBackwardFence || next.key != backwardFence);
+                return previous != null && (unboundBackwardFence || previous.key != backwardFence);
 			}
 			
 			@Override
 			public KEY_TYPE PREVIOUS() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				lastReturned = next;
+				lastReturned = previous;
-				KEY_TYPE result = next.key;
+				next = previous;
-				next = next.next();
+				KEY_TYPE result = previous.key;
+				previous = previous.next();
 				forwards = true;
 				return result;
 			}
@@ -1404,6 +1404,8 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			@Override
 			public void remove() {
 				if(lastReturned == null) throw new IllegalStateException();
+				if(previous == lastReturned) previous = previous.next();
+				if(next == lastReturned) next = next.previous();
 				if(forwards && lastReturned.needsSuccessor()) next = lastReturned;
 				set.removeNode(lastReturned);
 				lastReturned = null;
@@ -1415,11 +1417,13 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	{
 		Entry KEY_GENERIC_TYPE lastReturned;
 		Entry KEY_GENERIC_TYPE next;
+		Entry KEY_GENERIC_TYPE previous;
 		boolean forwards = false;
 		
 		public AscendingSetIterator(Entry KEY_GENERIC_TYPE first)
 		{
 			next = first;
+			previous = first == null ? null : first.previous();
 		}
 		
 		@Override
@@ -1431,6 +1435,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
 			lastReturned = next;
+			previous = next;
 			KEY_TYPE result = next.key;
 			next = next.next();
 			forwards = true;
@@ -1439,15 +1444,16 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		
 		@Override
 		public boolean hasPrevious() {
-            return next != null;
+            return previous != null;
 		}
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			lastReturned = next;
+			lastReturned = previous;
-			KEY_TYPE result = next.key;
+			next = previous;
-			next = next.previous();
+			KEY_TYPE result = previous.key;
+			previous = previous.previous();
 			forwards = false;
 			return result;
 		}
@@ -1455,6 +1461,8 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		@Override
 		public void remove() {
 			if(lastReturned == null) throw new IllegalStateException();
+			if(lastReturned == previous) previous = previous.previous();
+			if(lastReturned == next) next = next.next();
 			if(forwards && lastReturned.needsSuccessor()) next = lastReturned;
 			removeNode(lastReturned);
 			lastReturned = null;
@@ -1465,11 +1473,13 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	{
 		Entry KEY_GENERIC_TYPE lastReturned;
 		Entry KEY_GENERIC_TYPE next;
+		Entry KEY_GENERIC_TYPE previous;
 		boolean forwards = false;
 
 		public DescendingSetIterator(Entry KEY_GENERIC_TYPE first)
 		{
 			next = first;
+			previous = first == null ? null : first.next();
 		}
 		
 		@Override
@@ -1481,6 +1491,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
 			lastReturned = next;
+			previous = next;
 			KEY_TYPE result = next.key;
 			next = next.previous();
 			forwards = false;
@@ -1489,15 +1500,16 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		
 		@Override
 		public boolean hasPrevious() {
-            return next != null;
+            return previous != null;
 		}
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			lastReturned = next;
+			lastReturned = previous;
-			KEY_TYPE result = next.key;
+			next = previous;
-			next = next.next();
+			KEY_TYPE result = previous.key;
+			previous = previous.next();
 			forwards = true;
 			return result;
 		}
@@ -1505,6 +1517,8 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		@Override
 		public void remove() {
 			if(lastReturned == null) throw new IllegalStateException();
+			if(lastReturned == previous) previous = previous.next();
+			if(lastReturned == next) next = next.previous();
 			if(forwards && lastReturned.needsSuccessor()) next = lastReturned;
 			removeNode(lastReturned);
 			lastReturned = null;

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

@@ -54,6 +54,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	 * @throws NegativeArraySizeException if the capacity is negative
 	 */
 	public ARRAY_SET(int capacity) {
+		if(capacity < 0) throw new IllegalStateException("Size has to be 0 or greater");
 		data = NEW_KEY_ARRAY(capacity);
 	}
 	
@@ -168,7 +169,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		}
 		else if(index != size - 1) {
 			o = data[index];
-			System.arraycopy(data, index+1, data, index, size - index);
+			System.arraycopy(data, index+1, data, index, size - index - 1);
 			data[size-1] = o;
 		}
 		return false;
@@ -555,347 +556,6 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return a;
 	}
 		
-//	Disabled until a Proper Implementation can be thought out or it is decided that the interface is thrown out.
-//	private class SubSet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
-//		int offset;
-//		int length;
-//		
-//		SubSet(int offset, int length) {
-//			this.offset = offset;
-//			this.length = length;
-//		}
-//		
-//		int end() { return offset+length; }
-//
-//		@Override
-//		public boolean add(KEY_TYPE o) {
-//			int index = findIndex(o);
-//			if(index == -1) {
-//				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
-//				if(end() != size) System.arraycopy(data, end(), data, end()+1, size-(offset+length));
-//				data[end()] = o;
-//				size++;
-//				length++;
-//				return true;
-//			}
-//			return false;
-//		}
-//
-//		@Override
-//		public boolean addAndMoveToFirst(KEY_TYPE o) {
-//			int index = findIndex(o);
-//			if(index == -1) {
-//				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
-//				System.arraycopy(data, offset, data, offset+1, size-offset);
-//				data[offset] = o;
-//				size++;
-//				length++;
-//				return true;
-//			}
-//			else if(index != 0) {
-//				o = data[index];
-//				System.arraycopy(data, offset, data, offset+1, index-offset);
-//				data[offset] = o;
-//			}
-//			return false;
-//		}
-//		
-//		@Override
-//		public boolean addAndMoveToLast(KEY_TYPE o) {
-//			int index = findIndex(o);
-//			if(index == -1) {
-//				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
-//				System.arraycopy(data, end()+1, data, end(), size-end());
-//				data[end()] = o;
-//				size++;
-//				length++;
-//				return true;
-//			}
-//			else if(index != 0) {
-//				o = data[index];
-//				System.arraycopy(data, offset+1, data, offset, index-offset);
-//				data[offset+length] = o;
-//			}
-//			return false;
-//		}
-//		
-//		@Override
-//		public boolean moveToFirst(KEY_TYPE o) {
-//			int index = findIndex(o);
-//			if(index > offset) {
-//				o = data[index];
-//				System.arraycopy(data, offset, data, offset+1, index-offset);
-//				data[offset] = o;
-//				return true;
-//			}
-//			return false;
-//		}
-//		
-//		@Override
-//		public boolean moveToLast(KEY_TYPE o) {
-//			int index = findIndex(o);
-//			if(index != -1 && index < end()-1) {
-//				o = data[index];
-//				System.arraycopy(data, index+1, data, index, end()-index-1);
-//				data[end()-1] = o;
-//				return true;
-//			}
-//			return false;
-//		}
-//		
-//#if !TYPE_OBJECT
-//		@Override
-//		public boolean contains(KEY_TYPE e) {
-//			return findIndex(e) != -1;
-//		}
-//		
-//#endif
-//		@Override
-//		public boolean contains(Object e) {
-//			return findIndex(e) != -1;
-//		}
-//		
-//		@Override
-//		public KEY_TYPE FIRST_KEY() {
-//			if(length == 0) throw new NoSuchElementException();
-//			return data[offset];
-//		}
-//		
-//		@Override
-//		public KEY_TYPE LAST_KEY() {
-//			if(length == 0) throw new NoSuchElementException();
-//			return data[end()-1];
-//		}
-//		
-//#if !TYPE_OBJECT
-//		@Override
-//		public boolean remove(KEY_TYPE o) {
-//			int index = findIndex(o);
-//			if(index != -1) {
-//				size--;
-//				length--;
-//				if(index != size) System.arraycopy(data, index+1, data, index, size - index);
-//				return true;
-//			}
-//			return false;
-//		}
-//		
-//#endif
-//		@Override
-//		public boolean remove(Object o) {
-//			int index = findIndex(o);
-//			if(index != -1) {
-//				size--;
-//				length--;
-//				if(index != size) System.arraycopy(data, index+1, data, index, size - index);
-//#if TYPE_OBJECT
-//				data[size] = EMPTY_KEY_VALUE;
-//#endif
-//				return true;
-//			}
-//			return false;
-//		}
-//		
-//		@Override
-//		public KEY_TYPE POLL_FIRST_KEY() {
-//			if(length == 0) throw new NoSuchElementException();
-//			size--;
-//			length--;
-//			KEY_TYPE result = data[offset];
-//			System.arraycopy(data, offset+1, data, offset, size-offset);
-//#if TYPE_OBJECT
-//			data[size] = EMPTY_KEY_VALUE;
-//#endif
-//			return result;
-//		}
-//		
-//		@Override
-//		public KEY_TYPE POLL_LAST_KEY() {
-//			if(length == 0) throw new NoSuchElementException();
-//			KEY_TYPE result = data[offset+length];
-//			size--;
-//			length--;
-//			System.arraycopy(data, end()+1, data, end(), size-end());
-//#if TYPE_OBJECT
-//			data[size] = EMPTY_KEY_VALUE;
-//#endif
-//			return result;
-//		}
-//		
-//		@Override
-//		public COMPARATOR KEY_GENERIC_TYPE comparator() {
-//			return null;
-//		}
-//
-//		@Override
-//		public BI_ITERATOR KEY_GENERIC_TYPE iterator() {
-//			return new SetIterator(offset);
-//		}
-//
-//		@Override
-//		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
-//			int index = findIndex(fromElement);
-//			if(index != -1) return new SetIterator(index);
-//			throw new NoSuchElementException();
-//		}
-//		
-//		@Override
-//		public SubSet copy() { throw new UnsupportedOperationException(); }
-//		
-//		@Override
-//		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) {
-//			int fromIndex = findIndex(fromElement);
-//			int toIndex = findIndex(toElement);
-//			if(fromIndex == -1 || toIndex == -1) throw new NoSuchElementException();
-//			return new SubSet(fromIndex, toIndex - fromIndex + 1);
-//		}
-//
-//		@Override
-//		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) {
-//			int toIndex = findIndex(toElement);
-//			if(toIndex == -1) throw new NoSuchElementException();
-//			return new SubSet(0, toIndex+1);
-//		}
-//
-//		@Override
-//		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) {
-//			int fromIndex = findIndex(fromElement);
-//			if(fromIndex == -1) throw new NoSuchElementException();
-//			return new SubSet(fromIndex, size - fromIndex);
-//		}
-//		
-//		@Override
-//		public int size() {
-//			return length;
-//		}
-//		
-//#if !TYPE_OBJECT
-//		@Override
-//		public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
-//			if(a == null || a.length < size()) return Arrays.copyOfRange(data, offset, end());
-//			System.arraycopy(data, offset, a, 0, size());
-//			return a;
-//		}
-//		
-//#endif
-//		@Override
-//		@Deprecated
-//		public Object[] toArray() {
-//			Object[] obj = new Object[size()];
-//			for(int i = 0;i<size();i++)
-//				obj[i] = KEY_TO_OBJ(data[offset+i]);
-//			return obj;
-//		}
-//		
-//		@Override
-//		@Primitive
-//		public <E> E[] toArray(E[] a) {
-//			if(a == null) a = (E[])new Object[size()];
-//			else if(a.length < size()) a = (E[])ObjectArrays.newArray(a.getClass().getComponentType(), size());
-//			for(int i = 0;i<size();i++)
-//				a[i] = (E)KEY_TO_OBJ(data[offset+i]);
-//			return a;
-//		}
-//		
-//#if !TYPE_OBJECT
-//		protected int findIndex(KEY_TYPE o) {
-//			for(int i = length-1;i>=0;i--)
-//				if(KEY_EQUALS(data[offset+i], o)) return i + offset;
-//			return -1;
-//		}
-//		
-//#endif
-//		protected int findIndex(Object o) {
-//			for(int i = length-1;i>=0;i--)
-//				if(EQUALS_KEY_TYPE(data[offset+i], o)) return i + offset;
-//			return -1;
-//		}
-//		
-//		private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
-//			int index;
-//			int lastReturned = -1;
-//			
-//			public SetIterator(int index) {
-//				this.index = index;
-//			}
-//			
-//			@Override
-//			public boolean hasNext() {
-//				return index < size();
-//			}
-//			
-//			@Override
-//			public KEY_TYPE NEXT() {
-//				if(!hasNext()) throw new NoSuchElementException();
-//				lastReturned = index;
-//				return data[index++];
-//			}
-//			
-//			@Override
-//			public boolean hasPrevious() {
-//				return index > 0;
-//			}
-//			
-//			@Override
-//			public KEY_TYPE PREVIOUS() {
-//				if(!hasPrevious()) throw new NoSuchElementException();
-//				lastReturned = index;
-//				return data[index--];
-//			}
-//			
-//			@Override
-//			public int nextIndex() {
-//				return index;
-//			}
-//			
-//			@Override
-//			public int previousIndex() {
-//				return index-1;
-//			}
-//			
-//			@Override
-//			public void remove() {
-//				if(lastReturned == -1)
-//					throw new IllegalStateException();
-//				SubSet.this.remove(data[lastReturned]);
-//				if(lastReturned < index)
-//					index--;
-//				lastReturned = -1;
-//			}
-//			
-//		#if TYPE_OBJECT
-//			@Override
-//			public void set(Object e) { throw new UnsupportedOperationException(); }
-//			
-//			@Override
-//			public void add(Object e) { throw new UnsupportedOperationException(); }
-//			
-//		#else
-//			@Override
-//			public void set(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-//		
-//			@Override
-//			public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-//			
-//		#endif
-//			@Override
-//			public int skip(int amount) {
-//				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-//				int steps = Math.min(amount, (size() - 1) - index);
-//				index += steps;
-//				return steps;
-//			}
-//			
-//			@Override
-//			public int back(int amount) {
-//				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-//				int steps = Math.min(amount, index);
-//				index -= steps;
-//				return steps;
-//			}
-//		}
-//	}
-	
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		int index;
 		int lastReturned = -1;
@@ -924,8 +584,8 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			lastReturned = index;
+			--index;
-			return data[index--];
+			return data[(lastReturned = index)];
 		}
 		
 		@Override
@@ -964,8 +624,9 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		@Override
 		public int skip(int amount) {
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-			int steps = Math.min(amount, (size() - 1) - index);
+			int steps = Math.min(amount, size() - index);
 			index += steps;
+			if(steps > 0) lastReturned = Math.min(index-1, size()-1);
 			return steps;
 		}
 		
@@ -974,6 +635,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
 			int steps = Math.min(amount, index);
 			index -= steps;
+			if(steps > 0) lastReturned = Math.min(index, size()-1);
 			return steps;
 		}
 	}

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

@@ -502,6 +502,30 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 			}
 		}
 		
+		@Override
+		public int skip(int amount) {
+			int result = 0;
+			while(next != -1 && result != amount) {
+				current = previous = next;
+				next = (int)(links[current]);
+				result++;
+			}
+			if(index >= 0) index+=result;
+			return result;
+		}
+		
+		@Override
+		public int back(int amount) {
+			int result = 0;
+			while(previous != -1 && result != amount) {
+				current = next = previous;
+				previous = (int)(links[current] >> 32);
+				result++;
+			}
+			if(index >= 0) index-=result;
+			return result;
+		}
+		
 		@Override
 		public boolean hasNext() {
 			return next != -1;
@@ -530,9 +554,8 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			current = previous;
+			current = next = previous;
 			previous = (int)(links[current] >> 32);
-			next = current;
 			if(index >= 0) index--;
 			return keys[current];
 		}
@@ -540,9 +563,8 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			current = next;
+			current = previous = next;
 			next = (int)(links[current]);
-			previous = current;
 			if(index >= 0) index++;
 			return keys[current];
 		}

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

@@ -123,7 +123,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	 * @throws IllegalStateException if offset and length causes to step outside of the arrays range
 	 */
 	public LINKED_CUSTOM_HASH_SET(KEY_TYPE[] array, int offset, int length, float loadFactor, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
-		this(length < 0 ? 0 : length, strategy);
+		this(length, strategy);
 		SanityChecks.checkArrayCapacity(array.length, offset, length);
 		for(int i = 0;i<length;i++) add(array[offset+i]);
 	}
@@ -237,6 +237,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 			}
 			containsNull = true;
 			onNodeAdded(nullIndex);
+			moveToFirstIndex(nullIndex);
 		}
 		else {
 			int pos = HashUtil.mix(strategy.hashCode(o)) & mask;
@@ -249,6 +250,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 			}
 			keys[pos] = o;
 			onNodeAdded(pos);
+			moveToFirstIndex(pos);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return true;
@@ -282,7 +284,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	
 	@Override
 	public boolean moveToFirst(KEY_TYPE o) {
-		if(strategy.equals(FIRST_KEY(), o)) return false;
+		if(isEmpty() || strategy.equals(FIRST_KEY(), o)) return false;
 		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
 				moveToFirstIndex(nullIndex);
@@ -304,7 +306,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	
 	@Override
 	public boolean moveToLast(KEY_TYPE o) {
-		if(strategy.equals(LAST_KEY(), o)) return false;
+		if(isEmpty() || strategy.equals(LAST_KEY(), o)) return false;
 		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
 				moveToLastIndex(nullIndex);
@@ -370,8 +372,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	public KEY_TYPE POLL_FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = firstIndex;
-		firstIndex = (int)links[pos];
+		onNodeRemoved(pos);
-		if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L;
 		KEY_TYPE result = keys[pos];
 		size--;
 		if(strategy.equals(result, EMPTY_KEY_VALUE)) {
@@ -393,8 +394,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	public KEY_TYPE POLL_LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = lastIndex;
-		lastIndex = (int)(links[pos] >>> 32);
+		onNodeRemoved(pos);
-		if(0 <= lastIndex) links[lastIndex] |= 0xFFFFFFFFL;
 		KEY_TYPE result = keys[pos];
 		size--;
 		if(strategy.equals(result, EMPTY_KEY_VALUE)) {
@@ -508,7 +508,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	@Override
 	public void clearAndTrim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size) {
+		if(request >= nullIndex) {
 			clear();
 			return;
 		}
@@ -715,6 +715,30 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 			return previous != -1;
 		}
 		
+		@Override
+		public int skip(int amount) {
+			int result = 0;
+			while(next != -1 && result != amount) {
+				current = previous = next;
+				next = (int)(links[current]);
+				result++;
+			}
+			if(index >= 0) index+=result;
+			return result;
+		}
+		
+		@Override
+		public int back(int amount) {
+			int result = 0;
+			while(previous != -1 && result != amount) {
+				current = next = previous;
+				previous = (int)(links[current] >> 32);
+				result++;
+			}
+			if(index >= 0) index-=result;
+			return result;
+		}
+		
 		@Override
 		public int nextIndex() {
 			ensureIndexKnown();
@@ -773,9 +797,8 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			current = previous;
+			current = next = previous;
 			previous = (int)(links[current] >> 32);
-			next = current;
 			if(index >= 0) index--;
 			return keys[current];
 		}
@@ -783,9 +806,8 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			current = next;
+			current = previous = next;
 			next = (int)(links[current]);
-			previous = current;
 			if(index >= 0) index++;
 			return keys[current];
 		}

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

@@ -110,7 +110,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	 * @throws IllegalStateException if offset and length causes to step outside of the arrays range
 	 */
 	public LINKED_HASH_SET(KEY_TYPE[] array, int offset, int length, float loadFactor) {
-		this(length < 0 ? 0 : length);
+		this(length);
 		SanityChecks.checkArrayCapacity(array.length, offset, length);
 		for(int i = 0;i<length;i++) add(array[offset+i]);
 	}
@@ -208,6 +208,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 			}
 			containsNull = true;
 			onNodeAdded(nullIndex);
+			moveToFirstIndex(nullIndex);
 		}
 		else {
 			int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask;
@@ -220,6 +221,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 			}
 			keys[pos] = o;
 			onNodeAdded(pos);
+			moveToFirstIndex(pos);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return true;
@@ -253,7 +255,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	
 	@Override
 	public boolean moveToFirst(KEY_TYPE o) {
-		if(KEY_EQUALS(FIRST_KEY(), o)) return false;
+		if(isEmpty() || KEY_EQUALS(FIRST_KEY(), o)) return false;
 		if(KEY_EQUALS_NULL(o)) {
 			if(containsNull) {
 				moveToFirstIndex(nullIndex);
@@ -275,7 +277,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	
 	@Override
 	public boolean moveToLast(KEY_TYPE o) {
-		if(KEY_EQUALS(LAST_KEY(), o)) return false;
+		if(isEmpty() || KEY_EQUALS(LAST_KEY(), o)) return false;
 		if(KEY_EQUALS_NULL(o)) {
 			if(containsNull) {
 				moveToLastIndex(nullIndex);
@@ -341,8 +343,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	public KEY_TYPE POLL_FIRST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = firstIndex;
-		firstIndex = (int)links[pos];
+		onNodeRemoved(pos);
-		if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L;
 		KEY_TYPE result = keys[pos];
 		size--;
 		if(KEY_EQUALS_NULL(result)) {
@@ -364,8 +365,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	public KEY_TYPE POLL_LAST_KEY() {
 		if(size == 0) throw new NoSuchElementException();
 		int pos = lastIndex;
-		lastIndex = (int)(links[pos] >>> 32);
+		onNodeRemoved(pos);
-		if(0 <= lastIndex) links[lastIndex] |= 0xFFFFFFFFL;
 		KEY_TYPE result = keys[pos];
 		size--;
 		if(KEY_EQUALS_NULL(result)) {
@@ -599,7 +599,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	@Override
 	public void clearAndTrim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size) {
+		if(request >= nullIndex) {
 			clear();
 			return;
 		}
@@ -676,6 +676,30 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 			}
 		}
 		
+		@Override
+		public int skip(int amount) {
+			int result = 0;
+			while(next != -1 && result != amount) {
+				current = previous = next;
+				next = (int)(links[current]);
+				result++;
+			}
+			if(index >= 0) index+=result;
+			return result;
+		}
+		
+		@Override
+		public int back(int amount) {
+			int result = 0;
+			while(previous != -1 && result != amount) {
+				current = next = previous;
+				previous = (int)(links[current] >> 32);
+				result++;
+			}
+			if(index >= 0) index-=result;
+			return result;
+		}
+		
 		@Override
 		public boolean hasNext() {
 			return next != -1;
@@ -744,9 +768,8 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			current = previous;
+			current = next = previous;
 			previous = (int)(links[current] >> 32);
-			next = current;
 			if(index >= 0) index--;
 			return keys[current];
 		}
@@ -754,9 +777,8 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
-			current = next;
+			current = previous = next;
 			next = (int)(links[current]);
-			previous = current;
 			if(index >= 0) index++;
 			return keys[current];
 		}

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

@@ -373,10 +373,10 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 #endif
 	@Override
 	public boolean trim(int size) {
-		int newSize = HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor));
+		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(newSize >= nullIndex || size >= Math.min((int)Math.ceil(newSize * loadFactor), newSize - 1)) return false;
+		if(request >= nullIndex || this.size >= Math.min((int)Math.ceil(request * loadFactor), request - 1)) return false;
 		try {
-			rehash(newSize);
+			rehash(request);
 		}
 		catch(OutOfMemoryError e) { return false; }
 		return true;
@@ -385,7 +385,7 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 	@Override
 	public void clearAndTrim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size) {
+		if(request >= nullIndex) {
 			clear();
 			return;
 		}
@@ -589,7 +589,7 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 			state = keys[nullIndex];
 			empty = false;
 		}
-		for(int i = 0;i<size;i++) {
+		for(int i = nullIndex-1;i>=0;i--) {
 			if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
 			if(empty) {
 				empty = false;

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

@@ -340,10 +340,10 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 #endif
 	@Override
 	public boolean trim(int size) {
-		int newSize = HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor));
+		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(newSize >= nullIndex || size >= Math.min((int)Math.ceil(newSize * loadFactor), newSize - 1)) return false;
+		if(request >= nullIndex || this.size >= Math.min((int)Math.ceil(request * loadFactor), request - 1)) return false;
 		try {
-			rehash(newSize);
+			rehash(request);
 		}
 		catch(OutOfMemoryError e) { return false; }
 		return true;
@@ -352,7 +352,7 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 	@Override
 	public void clearAndTrim(int size) {
 		int request = Math.max(minCapacity, HashUtil.nextPowerOfTwo((int)Math.ceil(size / loadFactor)));
-		if(request >= size) {
+		if(request >= nullIndex) {
 			clear();
 			return;
 		}
@@ -452,7 +452,7 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 			state = keys[nullIndex];
 			empty = false;
 		}
-		for(int i = 0;i<size;i++) {
+		for(int i = nullIndex-1;i>=0;i--) {
 			if(KEY_EQUALS_NULL(keys[i])) continue;
 			if(empty) {
 				empty = false;

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

@@ -949,15 +949,11 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }
 		
-		public KEY_TYPE getDefaultMaxValue() { return super.getDefaultMinValue(); }
-		
-		public KEY_TYPE getDefaultMinValue() { return super.getDefaultMaxValue(); }
-		
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) {
 			if(!inRange(fromElement, fromInclusive)) throw new IllegalArgumentException("fromElement out of range");
 			if(!inRange(toElement, toInclusive)) throw new IllegalArgumentException("toElement out of range");
-			return new DescendingSubSetBRACES(set, false, fromElement, fromInclusive, false, toElement, toInclusive);
+			return new DescendingSubSetBRACES(set, false, toElement, toInclusive, false, fromElement, fromInclusive);
 		}
 		
 		@Override
@@ -1034,21 +1030,15 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 #if !TYPE_OBJECT
 		@Override
 		public void setDefaultMaxValue(KEY_TYPE value) { set.setDefaultMaxValue(value); }
-		
 		@Override
 		public KEY_TYPE getDefaultMaxValue() { return set.getDefaultMaxValue(); }
-		
 		@Override
 		public void setDefaultMinValue(KEY_TYPE value) { set.setDefaultMinValue(value); }
-		
 		@Override
 		public KEY_TYPE getDefaultMinValue() { return set.getDefaultMinValue(); }
-		
 #else
 		public KEY_TYPE getDefaultMaxValue() { return null; }
-		
 		public KEY_TYPE getDefaultMinValue() { return null; }
-		
 #endif
 		@Override
 		public abstract	BI_ITERATOR KEY_GENERIC_TYPE iterator();
@@ -1359,6 +1349,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		{
 			Entry KEY_GENERIC_TYPE lastReturned;
 			Entry KEY_GENERIC_TYPE next;
+			Entry KEY_GENERIC_TYPE previous;
 			boolean forwards = false;
 			boolean unboundForwardFence;
 			boolean unboundBackwardFence;
@@ -1368,6 +1359,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			public AscendingSubSetIterator(Entry KEY_GENERIC_TYPE first, Entry KEY_GENERIC_TYPE forwardFence, Entry KEY_GENERIC_TYPE backwardFence)
 			{
 				next = first;
+				previous = first == null ? null : first.previous();
 				this.forwardFence = forwardFence == null ? EMPTY_KEY_VALUE : forwardFence.key;
 				this.backwardFence = backwardFence == null ? EMPTY_KEY_VALUE : backwardFence.key;
 				unboundForwardFence = forwardFence == null;
@@ -1383,6 +1375,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			public KEY_TYPE NEXT() {
 				if(!hasNext()) throw new NoSuchElementException();
 				lastReturned = next;
+				previous = next;
 				KEY_TYPE result = next.key;
 				next = next.next();
 				forwards = true;
@@ -1391,15 +1384,16 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			
 			@Override
 			public boolean hasPrevious() {
-                return next != null && (unboundBackwardFence || next.key != backwardFence);
+                return previous != null && (unboundBackwardFence || previous.key != backwardFence);
 			}
 			
 			@Override
 			public KEY_TYPE PREVIOUS() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				lastReturned = next;
+				lastReturned = previous;
-				KEY_TYPE result = next.key;
+				next = previous;
-				next = next.previous();
+				KEY_TYPE result = previous.key;
+				previous = previous.previous();
 				forwards = false;
 				return result;
 			}
@@ -1407,6 +1401,8 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			@Override
 			public void remove() {
 				if(lastReturned == null) throw new IllegalStateException();
+				if(previous == lastReturned) previous = previous.previous();
+				if(next == lastReturned) next = next.next();
 				if(forwards && lastReturned.needsSuccessor()) next = lastReturned;
 				set.removeNode(lastReturned);
 				lastReturned = null;
@@ -1417,6 +1413,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		{
 			Entry KEY_GENERIC_TYPE lastReturned;
 			Entry KEY_GENERIC_TYPE next;
+			Entry KEY_GENERIC_TYPE previous;
 			boolean forwards = false;
 			boolean unboundForwardFence;
 			boolean unboundBackwardFence;
@@ -1426,6 +1423,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			public DescendingSubSetIterator(Entry KEY_GENERIC_TYPE first, Entry KEY_GENERIC_TYPE forwardFence, Entry KEY_GENERIC_TYPE backwardFence)
 			{
 				next = first;
+				previous = first == null ? null : first.next();
 				this.forwardFence = forwardFence == null ? EMPTY_KEY_VALUE : forwardFence.key;
 				this.backwardFence = backwardFence == null ? EMPTY_KEY_VALUE : backwardFence.key;
 				unboundForwardFence = forwardFence == null;
@@ -1441,6 +1439,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			public KEY_TYPE NEXT() {
 				if(!hasNext()) throw new NoSuchElementException();
 				lastReturned = next;
+				previous = next;
 				KEY_TYPE result = next.key;
 				next = next.previous();
 				forwards = false;
@@ -1449,15 +1448,16 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			
 			@Override
 			public boolean hasPrevious() {
-                return next != null && (unboundBackwardFence || next.key != backwardFence);
+                return previous != null && (unboundBackwardFence || previous.key != backwardFence);
 			}
 			
 			@Override
 			public KEY_TYPE PREVIOUS() {
 				if(!hasPrevious()) throw new NoSuchElementException();
-				lastReturned = next;
+				lastReturned = previous;
-				KEY_TYPE result = next.key;
+				next = previous;
-				next = next.next();
+				KEY_TYPE result = previous.key;
+				previous = previous.next();
 				forwards = true;
 				return result;
 			}
@@ -1465,6 +1465,8 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			@Override
 			public void remove() {
 				if(lastReturned == null) throw new IllegalStateException();
+				if(previous == lastReturned) previous = previous.next();
+				if(next == lastReturned) next = next.previous();
 				if(forwards && lastReturned.needsSuccessor()) next = lastReturned;
 				set.removeNode(lastReturned);
 				lastReturned = null;
@@ -1476,11 +1478,13 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	{
 		Entry KEY_GENERIC_TYPE lastReturned;
 		Entry KEY_GENERIC_TYPE next;
+		Entry KEY_GENERIC_TYPE previous;
 		boolean forwards = false;
 		
 		public AscendingSetIterator(Entry KEY_GENERIC_TYPE first)
 		{
 			next = first;
+			previous = first == null ? null : first.previous();
 		}
 		
 		@Override
@@ -1492,6 +1496,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
 			lastReturned = next;
+			previous = next;
 			KEY_TYPE result = next.key;
 			next = next.next();
 			forwards = true;
@@ -1500,15 +1505,16 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		
 		@Override
 		public boolean hasPrevious() {
-            return next != null;
+            return previous != null;
 		}
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			lastReturned = next;
+			lastReturned = previous;
-			KEY_TYPE result = next.key;
+			next = previous;
-			next = next.previous();
+			KEY_TYPE result = previous.key;
+			previous = previous.previous();
 			forwards = false;
 			return result;
 		}
@@ -1516,6 +1522,8 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		@Override
 		public void remove() {
 			if(lastReturned == null) throw new IllegalStateException();
+			if(lastReturned == previous) previous = previous.previous();
+			if(lastReturned == next) next = next.next();
 			if(forwards && lastReturned.needsSuccessor()) next = lastReturned;
 			removeNode(lastReturned);
 			lastReturned = null;
@@ -1526,11 +1534,13 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	{
 		Entry KEY_GENERIC_TYPE lastReturned;
 		Entry KEY_GENERIC_TYPE next;
+		Entry KEY_GENERIC_TYPE previous;
 		boolean forwards = false;
 
 		public DescendingSetIterator(Entry KEY_GENERIC_TYPE first)
 		{
 			next = first;
+			previous = first == null ? null : first.next();
 		}
 		
 		@Override
@@ -1542,6 +1552,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
 			lastReturned = next;
+			previous = next;
 			KEY_TYPE result = next.key;
 			next = next.previous();
 			forwards = false;
@@ -1550,15 +1561,16 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		
 		@Override
 		public boolean hasPrevious() {
-            return next != null;
+            return previous != null;
 		}
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
 			if(!hasPrevious()) throw new NoSuchElementException();
-			lastReturned = next;
+			lastReturned = previous;
-			KEY_TYPE result = next.key;
+			next = previous;
-			next = next.next();
+			KEY_TYPE result = previous.key;
+			previous = previous.next();
 			forwards = true;
 			return result;
 		}
@@ -1566,6 +1578,8 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		@Override
 		public void remove() {
 			if(lastReturned == null) throw new IllegalStateException();
+			if(lastReturned == previous) previous = previous.next();
+			if(lastReturned == next) next = next.previous();
 			if(forwards && lastReturned.needsSuccessor()) next = lastReturned;
 			removeNode(lastReturned);
 			lastReturned = null;

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

@@ -348,9 +348,11 @@ public class ARRAYS
 	 * @param array the array that needs to be sorted
 	 * @ArrayType(T)
 	 * @param comp the Comparator that decides the sorting order
+	 * @return input array.
 	 */
-	public static GENERIC_KEY_BRACES void stableSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] stableSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
 		stableSort(array, 0, array.length, comp);
+		return array;
 	}
 	
 	/**
@@ -386,9 +388,11 @@ public class ARRAYS
 	 * Stable sort referres to Mergesort or Insertionsort
 	 * @param array the array that needs to be sorted
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void stableSort(KEY_TYPE[] array) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] stableSort(KEY_TYPE[] array) {
 		stableSort(array, 0, array.length);
+		return array;
 	}
 	
 	/**
@@ -423,9 +427,11 @@ public class ARRAYS
 	 * @param array the array that needs to be sorted
 	 * @param comp the Comparator that decides the sorting order
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void unstableSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] unstableSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
 		unstableSort(array, 0, array.length, comp);
+		return array;
 	}
 	
 	/**
@@ -461,9 +467,11 @@ public class ARRAYS
 	 * Unstable sort referres to QuickSort or SelectionSort
 	 * @param array the array that needs to be sorted
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void unstableSort(KEY_TYPE[] array) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] unstableSort(KEY_TYPE[] array) {
 		unstableSort(array, 0, array.length);
+		return array;
 	}
 	
 	/**
@@ -496,9 +504,11 @@ public class ARRAYS
 	 * @param array the array that needs to be sorted
 	 * @param comp the Comparator that decides the sorting order
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void insertionSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] insertionSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
 		insertionSort(array, 0, array.length, comp);
+		return array;
 	}
 	
 	/**
@@ -535,9 +545,11 @@ public class ARRAYS
 	 * Sorts an array according to the natural ascending order using InsertionSort, 
 	 * @param array the array that needs to be sorted
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void insertionSort(KEY_TYPE[] array) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] insertionSort(KEY_TYPE[] array) {
 		insertionSort(array, 0, array.length);
+		return array;
 	}
 	
 	/**
@@ -573,9 +585,11 @@ public class ARRAYS
 	 * @param array the array that needs to be sorted
 	 * @param comp the Comparator that decides the sorting order
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void selectionSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] selectionSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
 		selectionSort(array, 0, array.length, comp);
+		return array;
 	}
 	
 	/**
@@ -617,9 +631,11 @@ public class ARRAYS
 	 * Sorts an array according to the natural ascending order using Selection Sort, 
 	 * @param array the array that needs to be sorted
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void selectionSort(KEY_TYPE[] array) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] selectionSort(KEY_TYPE[] array) {
 		selectionSort(array, 0, array.length);
+		return array;
 	}
 	
 	/**
@@ -661,9 +677,11 @@ public class ARRAYS
 	 * @param array the array that needs to be sorted
 	 * @param comp the Comparator that decides the sorting order
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void mergeSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] mergeSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
 		mergeSort(array, null, 0, array.length, comp);
+		return array;
 	}
 	
 	/**
@@ -713,9 +731,11 @@ public class ARRAYS
 	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
 	 * @param array the array that needs to be sorted
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void mergeSort(KEY_TYPE[] array) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] mergeSort(KEY_TYPE[] array) {
 		mergeSort(array, null, 0, array.length);
+		return array;
 	}
 	
 	/**
@@ -922,9 +942,11 @@ public class ARRAYS
 	 * @author Speiger
 	 * @param array the array that needs to be sorted
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void memFreeMergeSort(KEY_TYPE[] array) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] memFreeMergeSort(KEY_TYPE[] array) {
 		memFreeMergeSort(array, 0, array.length);
+		return array;
 	}
 	
 	/**
@@ -1099,9 +1121,11 @@ public class ARRAYS
 	 * @param array the array that needs to be sorted
 	 * @param comp the Comparator that decides the sorting order
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void quickSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] quickSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp) {
 		quickSort(array, 0, array.length, comp);
+		return array;
 	}
 	
 	/**
@@ -1157,9 +1181,11 @@ public class ARRAYS
 	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
 	 * @param array the array that needs to be sorted
 	 * @ArrayType(T)
+	 * @return input array
 	 */
-	public static GENERIC_KEY_BRACES void quickSort(KEY_TYPE[] array) {
+	public static GENERIC_KEY_BRACES KEY_TYPE[] quickSort(KEY_TYPE[] array) {
 		quickSort(array, 0, array.length);
+		return array;
 	}
 	
 	/**

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

@@ -7,12 +7,13 @@ 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;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #else
 import java.util.function.BiFunction;
+import java.util.Comparator;
 
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERABLE;
@@ -112,6 +113,16 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		return new ASYNC_BUILDERBRACES(ITERABLES.wrap(iterable));
 	}
 	
+	/**
+	 * Helper function that automatically wraps a array into a AsyncBuilder since it forces this collections Iterable.
+	 * @param values that should be wrapped
+	 * @Type(T)
+	 * @return a AsyncBuilder with the values wrapped
+	 */
+	public static GENERIC_KEY_BRACES ASYNC_BUILDER KEY_GENERIC_TYPE of(KEY_TYPE...values) {
+		return new ASYNC_BUILDERBRACES(ARRAY_LIST.wrap(values));
+	}
+	
 	/**
 	 * Maps the elements to something else
 	 * @param mapper the mapping function
@@ -172,6 +183,17 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		return this;
 	}
 	
+	/**
+	 * Sorts the elements inside of the Iterable.
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it, and this will affect the pausing feature.
+	 * @param sorter that sorts the elements.
+	 * @return self with a sorter applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE sorted(COMPARATOR KEY_GENERIC_TYPE sorter) {
+		iterable = ITERABLES.sorted(iterable, sorter);
+		return this;
+	}
+	
 	/**
 	 * Allows to preview elements before they are processed
 	 * @param action the action that should be applied

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

@@ -186,7 +186,10 @@ public class COLLECTIONS
 		@Override
 		public int hashCode() { synchronized(mutex) { return c.hashCode(); } }
 		@Override
-		public boolean equals(Object obj) { synchronized(mutex) { return c.equals(obj); } }
+		public boolean equals(Object obj) {
+			if(obj == this) return true;
+			synchronized(mutex) { return c.equals(obj); } 
+		}
 		@Override
 		public String toString() { synchronized(mutex) { return c.toString(); } }
 		@Override
@@ -308,7 +311,7 @@ public class COLLECTIONS
 		@Override
 		public int hashCode() { return c.hashCode(); }
 		@Override
-		public boolean equals(Object obj) { return c.equals(obj); }
+		public boolean equals(Object obj) { return obj == this || c.equals(obj); }
 		@Override
 		public String toString() { return c.toString(); }
 		@Override
@@ -350,7 +353,7 @@ public class COLLECTIONS
 		@Override
 		public boolean contains(KEY_TYPE o) { return false; }
 		@Override
-		public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c) { return false; }
+		public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c) { return c.isEmpty(); }
 		@Override
 		public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c) { return false; }
 #else
@@ -362,7 +365,7 @@ public class COLLECTIONS
 		public boolean containsAny(Collection<?> c) { return false; }
 		@Override
 		@Primitive
-		public boolean containsAll(Collection<?> c) { return false; }
+		public boolean containsAll(Collection<?> c) { return c.isEmpty(); }
 		@Override
 		public int hashCode() { return 0; }
 		
@@ -401,14 +404,28 @@ public class COLLECTIONS
 		public Object[] toArray() { return ObjectArrays.EMPTY_ARRAY; }
 #if !TYPE_OBJECT
 		@Override
-		public <T> T[] toArray(T[] a) { return a; }
+		public <T> T[] toArray(T[] a) {
+			if(a != null && a.length > 0)
+				a[0] = null;
+			return a;
+		}
+		
 		@Override
 		public KEY_TYPE[] TO_ARRAY() { return ARRAYS.EMPTY_ARRAY; }
 		@Override
-		public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) { return a; }
+		public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
+			if(a != null && a.length > 0)
+				a[0] = EMPTY_KEY_VALUE;
+			return a;
+		}
+		
 #else
 		@Override
-		public <E> E[] toArray(E[] a) { return a; }
+		public <E> E[] toArray(E[] a) {
+			if(a != null && a.length > 0)
+				a[0] = EMPTY_KEY_VALUE;
+			return a;
+		}
 #endif
 		@Override
 		public ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.empty(); }

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

@@ -3,6 +3,8 @@ package speiger.src.collections.PACKAGE.utils;
 import java.util.Objects;
 #if TYPE_BOOLEAN
 import java.util.concurrent.atomic.AtomicInteger;
+#else if TYPE_OBJECT
+import java.util.Comparator;
 #endif
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
@@ -12,8 +14,11 @@ import speiger.src.collections.PACKAGE.collections.ITERABLE;
 import speiger.src.collections.objects.collections.ObjectIterable;
 import speiger.src.collections.objects.collections.ObjectIterator;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #if !TYPE_BOOLEAN
@@ -164,6 +169,30 @@ public class ITERABLES
 		return new LimitedIterableBRACES(wrap(iterable), limit);
 	}
 	
+	/**
+	 * A Helper function that sorts the Iterable.
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it.
+	 * @param iterable that should be sorted
+	 * @param sorter that sorts the iterable. Can be null.
+	 * @Type(T)
+	 * @return a sorted iterable.
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE sorted(ITERABLE KEY_GENERIC_TYPE iterable, COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return new SortedIterableBRACES(iterable, sorter);
+	}
+	
+	/**
+	 * A Helper function that sorts the Iterable from a Java Iterable
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it.
+	 * @param iterable that should be sorted
+	 * @param sorter that sorts the iterable. Can be null.
+	 * @Type(T)
+	 * @return a sorted iterable.
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE sorted(Iterable<? extends CLASS_TYPE> iterable, COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return new SortedIterableBRACES(wrap(iterable), sorter);
+	}
+	
 	/**
 	 * A Helper function that allows to preview the result of a Iterable.
 	 * @param iterable that should be peeked at
@@ -359,6 +388,42 @@ public class ITERABLES
 #endif
 	}
 	
+	private static class SortedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	{
+		ITERABLE KEY_GENERIC_TYPE iterable;
+		COMPARATOR KEY_GENERIC_TYPE sorter;
+		
+		public SortedIterable(ITERABLE KEY_GENERIC_TYPE iterable, COMPARATOR KEY_GENERIC_TYPE sorter) {
+			this.iterable = iterable;
+			this.sorter = sorter;
+		}
+		
+		@Override
+		public ITERATOR KEY_GENERIC_TYPE iterator() {
+			return ITERATORS.sorted(iterable.iterator(), sorter);
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public void forEach(CONSUMER action) {
+			Objects.requireNonNull(action);
+			LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+			iterable.forEach(list::add);
+			list.unstableSort(sorter);
+			list.forEach(action);
+		}
+#else
+		@Override
+		public void forEach(Consumer<? super CLASS_TYPE> action) {
+			Objects.requireNonNull(action);
+			LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+			iterable.forEach(list::add);
+			list.unstableSort(sorter);
+			list.forEach(action);
+		}
+#endif
+	}
+	
 	private static class DistinctIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
 	{
 		ITERABLE KEY_GENERIC_TYPE iterable;

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

@@ -3,6 +3,7 @@ package speiger.src.collections.PACKAGE.utils;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 #if TYPE_OBJECT
+import java.util.Comparator;
 import java.util.function.CONSUMER;
 #endif
 
@@ -11,6 +12,7 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.objects.collections.ObjectIterator;
 import speiger.src.collections.objects.utils.ObjectIterators;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
@@ -32,7 +34,7 @@ public class ITERATORS
 	/**
 	 * Empty Iterator Reference
 	 */
-	public static final EmptyIterator NO_GENERIC_TYPE EMPTY = new EmptyIteratorBRACES();
+	private static final EmptyIterator NO_GENERIC_TYPE EMPTY = new EmptyIteratorBRACES();
 	
 	/**
 	 * Returns a Immutable EmptyIterator instance that is automatically casted.
@@ -235,6 +237,30 @@ public class ITERATORS
 		return new LimitedIteratorBRACES(wrap(iterator), limit);
 	}
 	
+	/**
+	 * A Helper function that sorts the Iterator beforehand.
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it.
+	 * @param iterator that should be sorted.
+	 * @param sorter the sorter of the iterator. Can be null.
+	 * @Type(T)
+	 * @return a new sorted iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE sorted(ITERATOR KEY_GENERIC_TYPE iterator, COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return new SortedIteratorBRACES(iterator, sorter);
+	}
+	
+	/**
+	 * A Helper function that sorts the Iterator beforehand from a Java Iterator.
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it.
+	 * @param iterator that should be sorted.
+	 * @param sorter the sorter of the iterator. Can be null.
+	 * @Type(T)
+	 * @return a new sorted iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE sorted(Iterator<? extends CLASS_TYPE> iterator, COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return new SortedIteratorBRACES(wrap(iterator), sorter);
+	}
+	
 	/**
 	 * A Helper function that allows to preview the result of a Iterator.
 	 * @param iterator that should be peeked at
@@ -273,7 +299,7 @@ public class ITERATORS
 	 * @ArrayType(T)
 	 * @return a Iterator that is wrapping a array.
 	 */
-	public static GENERIC_KEY_BRACES ArrayIterator KEY_GENERIC_TYPE wrap(KEY_TYPE[] a) {
+	public static GENERIC_KEY_BRACES ArrayIterator KEY_GENERIC_TYPE wrap(KEY_TYPE... a) {
 		return wrap(a, 0, a.length);
 	}
 	
@@ -709,7 +735,7 @@ public class ITERATORS
 	
 		@Override
 		public KEY_TYPE NEXT() {
-			return EMPTY_KEY_VALUE;
+			throw new NoSuchElementException();
 		}
 
 		@Override
@@ -719,7 +745,7 @@ public class ITERATORS
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
-			return EMPTY_KEY_VALUE;
+			throw new NoSuchElementException();
 		}
 		
 		@Override
@@ -729,7 +755,7 @@ public class ITERATORS
 		
 		@Override
 		public int previousIndex() {
-			return 0;
+			return -1;
 		}
 		
 		@Override
@@ -761,6 +787,7 @@ public class ITERATORS
 		
 		@Override
 		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
 			return a[from++];
 		}
 		
@@ -828,7 +855,7 @@ public class ITERATORS
 		
 		@Override
 		public T next() {
-			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			if(!hasNext()) throw new NoSuchElementException();
 			T result = last.next();
 			foundNext = false;
 			return result;
@@ -864,13 +891,42 @@ public class ITERATORS
 		
 		@Override
 		public T next() {
-			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			if(!hasNext()) throw new NoSuchElementException();
 			T result = last.next();
 			foundNext = false;
 			return result;
 		}
 	}
 	
+	private static class SortedIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
+	{
+		ITERATOR KEY_GENERIC_TYPE iterator;
+		COMPARATOR KEY_GENERIC_TYPE sorter;
+		LIST KEY_GENERIC_TYPE sortedElements = null;
+		int index = 0;
+		
+		public SortedIterator(ITERATOR KEY_GENERIC_TYPE iterator, COMPARATOR KEY_GENERIC_TYPE sorter) {
+			this.iterator = iterator;
+			this.sorter = sorter;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			if(sortedElements == null) {
+				boolean hasNext = iterator.hasNext();
+				sortedElements = hasNext ? pour(iterator) : LISTS.empty();
+				if(hasNext) sortedElements.unstableSort(sorter);
+			}
+			return index < sortedElements.size();
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			return sortedElements.GET_KEY(index++);
+		}
+	}
+	
 	private static class DistinctIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
 	{
 		ITERATOR KEY_GENERIC_TYPE iterator;
@@ -916,7 +972,7 @@ public class ITERATORS
 		
 		@Override
 		public KEY_TYPE NEXT() {
-			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			if(!hasNext()) throw new NoSuchElementException();
 			foundNext = false;
 			return lastFound;
 		}
@@ -953,7 +1009,7 @@ public class ITERATORS
 		
 		@Override
 		public KEY_TYPE NEXT() {
-			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			if(!hasNext()) throw new NoSuchElementException();
 			foundNext = false;
 			return lastFound;
 		}
@@ -976,7 +1032,7 @@ public class ITERATORS
 		
 		@Override
 		public KEY_TYPE NEXT() {
-			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			if(!hasNext()) throw new NoSuchElementException();
 			limit--;
 			return iterator.NEXT();
 		}
@@ -999,7 +1055,7 @@ public class ITERATORS
 		
 		@Override
 		public KEY_TYPE NEXT() {
-			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			if(!hasNext()) throw new NoSuchElementException();
 			KEY_TYPE result = iterator.NEXT();
 			action.accept(result);
 			return result;

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

@@ -1,6 +1,7 @@
 package speiger.src.collections.PACKAGE.utils;
 
 import java.util.Collection;
+import java.util.List;
 import java.util.Objects;
 import java.util.Random;
 import java.util.RandomAccess;
@@ -27,7 +28,7 @@ public class LISTS
 	/**
 	 * Empty List reference
 	 */
-	public static final EmptyList NO_GENERIC_TYPE EMPTY = new EmptyListBRACES();
+	private static final EmptyList NO_GENERIC_TYPE EMPTY = new EmptyListBRACES();
 	
 	/**
 	 * Returns a Immutable EmptyList instance that is automatically casted.
@@ -356,7 +357,7 @@ public class LISTS
 		
 #endif
 		@Override
-		public void addElements(int from, KEY_TYPE[] a, int offset, int length) { synchronized(mutex) { addElements(from, a, offset, length); } }
+		public void addElements(int from, KEY_TYPE[] a, int offset, int length) { synchronized(mutex) { l.addElements(from, a, offset, length); } }
 		
 		@Override
 		public KEY_TYPE[] getElements(int from, KEY_TYPE[] a, int offset, int length) { synchronized(mutex) { return l.getElements(from, a, offset, length); } }
@@ -601,6 +602,16 @@ public class LISTS
 			return ITERATORS.empty();
 		}
 		
+		@Override
+		public int hashCode() { return 1; }
+		
+		@Override
+		public boolean equals(Object o) {
+			if(o == this) return true;
+			if(!(o instanceof List)) return false;
+			return ((List<?>)o).isEmpty();
+		}
+		
 		@Override
 		public LIST KEY_GENERIC_TYPE subList(int from, int to) { throw new UnsupportedOperationException(); }
 		

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

@@ -1,5 +1,7 @@
 package speiger.src.collections.PACKAGE.utils;
 
+import java.util.NoSuchElementException;
+import java.util.Set;
 #if TYPE_BOOLEAN
 import speiger.src.collections.booleans.collections.BooleanIterator;
 import speiger.src.collections.booleans.sets.AbstractBooleanSet;
@@ -34,7 +36,7 @@ public class SETS
 	/**
 	 * Empty Set Variable
 	 */
-	public static final SET NO_GENERIC_TYPE EMPTY = new EmptySetBRACES();
+	private static final SET NO_GENERIC_TYPE EMPTY = new EmptySetBRACES();
 	
 	/**
 	 * EmptySet getter
@@ -216,10 +218,10 @@ public class SETS
 			return new ITERATOR KEY_GENERIC_TYPE() {
 				boolean next = true;
 				@Override
-				public boolean hasNext() { return next = false; }
+				public boolean hasNext() { return next; }
 				@Override
 				public KEY_TYPE NEXT() {
-					if(!next) throw new IllegalStateException();
+					if(!hasNext()) throw new NoSuchElementException();
 					next = false;
 					return element;
 				}
@@ -241,6 +243,13 @@ public class SETS
 		@Override
 		public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 #endif
+		@Override
+		public boolean equals(Object o) {
+			if(o == this) return true;
+			if(!(o instanceof Set)) return false;
+			return ((Set<?>)o).isEmpty();
+		}
+		
 		@Override
 		public EmptySet KEY_GENERIC_TYPE copy() { return this; }
 	}
@@ -258,25 +267,38 @@ public class SETS
 #if !TYPE_OBJECT
 		@Override
 		public boolean contains(KEY_TYPE o) { return n.contains(o); }
+		@Override
+		@SuppressWarnings("deprecation")
+		public CLASS_TYPE lower(CLASS_TYPE e) { return n.lower(e); }
+		@Override
+		@SuppressWarnings("deprecation")
+		public CLASS_TYPE floor(CLASS_TYPE e) { return n.floor(e); }
+		@Override
+		@SuppressWarnings("deprecation")
+		public CLASS_TYPE ceiling(CLASS_TYPE e) { return n.ceiling(e); }
+		@Override
+		@SuppressWarnings("deprecation")
+		public CLASS_TYPE higher(CLASS_TYPE e) { return n.higher(e); }
 		
 #endif		
 		@Override
 		@Deprecated
 		public boolean contains(Object o) { return n.contains(o); }
-		
 		@Override
 		public KEY_TYPE lower(KEY_TYPE e) { return n.lower(e); }
-		
 		@Override
 		public KEY_TYPE floor(KEY_TYPE e) { return n.floor(e); }
-		
 		@Override
 		public KEY_TYPE ceiling(KEY_TYPE e) { return n.ceiling(e); }
-		
 		@Override
 		public KEY_TYPE higher(KEY_TYPE e) { return n.higher(e); }
 		
 #if !TYPE_OBJECT
+		@Override
+		public CLASS_TYPE pollFirst() { throw new UnsupportedOperationException(); }
+		@Override
+		public CLASS_TYPE pollLast() { throw new UnsupportedOperationException(); }
+
 		@Override
 		public void setDefaultMaxValue(KEY_TYPE e) { throw new UnsupportedOperationException(); }
 		
@@ -291,7 +313,7 @@ public class SETS
 		
 #endif
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE copy() { return n.copy(); }
 		
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { return SETS.unmodifiable(n.subSet(fromElement, fromInclusive, toElement, toInclusive)); }
@@ -454,27 +476,33 @@ public class SETS
 #if !TYPE_OBJECT
 		@Override
 		public boolean contains(KEY_TYPE o) { synchronized(mutex) { return n.contains(o); } }
-		
+		@Override
+		@SuppressWarnings("deprecation")
+		public CLASS_TYPE lower(CLASS_TYPE e) { synchronized(mutex) { return n.lower(e); } }
+		@Override
+		@SuppressWarnings("deprecation")
+		public CLASS_TYPE floor(CLASS_TYPE e) { synchronized(mutex) { return n.floor(e); } }
+		@Override
+		@SuppressWarnings("deprecation")
+		public CLASS_TYPE ceiling(CLASS_TYPE e) { synchronized(mutex) { return n.ceiling(e); } }
+		@Override
+		@SuppressWarnings("deprecation")
+		public CLASS_TYPE higher(CLASS_TYPE e) { synchronized(mutex) { return n.higher(e); } }
 #endif
 		@Override
 		public KEY_TYPE lower(KEY_TYPE e) { synchronized(mutex) { return n.lower(e); } }
-		
 		@Override
 		public KEY_TYPE floor(KEY_TYPE e) { synchronized(mutex) { return n.floor(e); } }
-		
 		@Override
 		public KEY_TYPE ceiling(KEY_TYPE e) { synchronized(mutex) { return n.ceiling(e); } }
-		
 		@Override
 		public KEY_TYPE higher(KEY_TYPE e) { synchronized(mutex) { return n.higher(e); } }
 		
 #if !TYPE_OBJECT
 		@Override
 		public void setDefaultMaxValue(KEY_TYPE e) { synchronized(mutex) { n.setDefaultMaxValue(e); } }
-		
 		@Override
 		public KEY_TYPE getDefaultMaxValue() { synchronized(mutex) { return n.getDefaultMaxValue(); } }
-		
 		@Override
 		public void setDefaultMinValue(KEY_TYPE e) { synchronized(mutex) { n.setDefaultMinValue(e); } }
 		

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

@@ -1,6 +1,7 @@
 package speiger.src.collections.PACKAGE.utils;
 
 import java.util.Comparator;
+import java.util.NoSuchElementException;
 import java.util.Spliterator;
 #if PRIMITIVES
 import java.util.Spliterator.JAVA_SPLIT_ITERATOR;
@@ -329,7 +330,11 @@ public class SPLIT_ITERATORS
 		}
 		
 		@Override
-		public KEY_TYPE NEXT() { return array[index++]; }
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			return array[index++];
+		}
+		
 		@Override
 		public boolean hasNext() { return index < fence; }
 	}

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

@@ -19,8 +19,11 @@ import speiger.src.collections.objects.collections.ObjectIterable;
 import speiger.src.collections.objects.collections.ObjectIterator;
 import speiger.src.collections.objects.sets.ObjectSet;
 #if !TYPE_BOOLEAN
+import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
+import speiger.src.collections.objects.utils.ObjectIterators;
 import speiger.src.collections.objects.utils.ObjectSets;
 #if !TYPE_OBJECT
+import speiger.src.collections.objects.sets.ObjectOrderedSet;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
@@ -34,6 +37,8 @@ import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_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.NAVIGABLE_SET;
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.PACKAGE.utils.SETS;
@@ -42,6 +47,7 @@ import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 #if !SAME_TYPE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
 #endif
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
 import speiger.src.collections.VALUE_PACKAGE.utils.VALUE_COLLECTIONS;
 #if !SAME_TYPE && !VALUE_OBJECT
 import speiger.src.collections.VALUE_PACKAGE.utils.VALUE_SETS;
@@ -57,7 +63,21 @@ public class MAPS
 	/**
 	 * Empty Map Variable
 	 */
-	public static final MAP NO_KV_GENERIC_TYPE EMPTY = new EmptyMapKV_BRACES();
+	private static final MAP NO_KV_GENERIC_TYPE EMPTY = new EmptyMapKV_BRACES();
+	
+	/**
+	 * Empty Map getter function that autocasts to the desired Key and Value
+	 * @Type(T)
+	 * @ValueType(V)
+	 * @return empty map of desired type
+	 */
+	public static GENERIC_KEY_VALUE_BRACES MAP KEY_VALUE_GENERIC_TYPE empty() { 
+#if TYPE_OBJECT || VALUE_OBJECT
+		return (MAP KEY_VALUE_GENERIC_TYPE)EMPTY;
+#else
+		return EMPTY;
+#endif
+	}
 	
 #endif	
 	/**
@@ -104,19 +124,6 @@ public class MAPS
 	}
 	
 #if !TYPE_BOOLEAN
-	/**
-	 * Empty Map getter function that autocasts to the desired Key and Value
-	 * @Type(T)
-	 * @ValueType(V)
-	 * @return empty map of desired type
-	 */
-	public static GENERIC_KEY_VALUE_BRACES MAP KEY_VALUE_GENERIC_TYPE empty() { 
-#if TYPE_OBJECT || VALUE_OBJECT
-		return (MAP KEY_VALUE_GENERIC_TYPE)EMPTY;
-#else
-		return EMPTY;
-#endif
-	}
 	
 	/**
 	 * Helper function that creates a Helper wrapper to synchronize access into the map.
@@ -253,7 +260,7 @@ public class MAPS
 	 * @ValueType(V)
 	 * @return a Unmodifyable Entry
 	 */
-	public static GENERIC_KEY_VALUE_BRACES MAP.Entry KEY_VALUE_GENERIC_TYPE unmodifiable(MAP.Entry KEY_VALUE_GENERIC_TYPE entry) { return entry instanceof UnmodifyableEntry ? entry : new UnmodifyableEntryKV_BRACES(entry); }
+	public static GENERIC_KEY_VALUE_BRACES MAP.Entry KEY_VALUE_GENERIC_TYPE unmodifiable(MAP.Entry KEY_VALUE_GENERIC_TYPE entry) { return entry instanceof UnmodifyableEntry ? entry : (entry == null ? null : new UnmodifyableEntryKV_BRACES(entry)); }
 	/**
 	 * A Helper function that creates a Unmodifyable Entry
 	 * @param entry the Entry that should be made unmodifiable
@@ -261,7 +268,7 @@ public class MAPS
 	 * @ValueType(V)
 	 * @return a Unmodifyable Entry
 	 */
-	public static GENERIC_KEY_VALUE_BRACES MAP.Entry KEY_VALUE_GENERIC_TYPE unmodifiable(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry) { return entry instanceof UnmodifyableEntry ? (UnmodifyableEntry KEY_VALUE_GENERIC_TYPE)entry : new UnmodifyableEntryKV_BRACES(entry); }
+	public static GENERIC_KEY_VALUE_BRACES MAP.Entry KEY_VALUE_GENERIC_TYPE unmodifiable(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry) { return entry instanceof UnmodifyableEntry ? (UnmodifyableEntry KEY_VALUE_GENERIC_TYPE)entry : (entry == null ? null : new UnmodifyableEntryKV_BRACES(entry)); }
 	
 	/**
 	 * Creates a Singleton map from the provided values.
@@ -315,6 +322,18 @@ public class MAPS
 		@Override
 		public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return EQUALS_KEY_TYPE(key, this.key) ? value : defaultValue; }
 #endif
+		@Override
+		public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public void BULK_MERGE(MAP KEY_VALUE_GENERIC_TYPE m, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
 		@Override
 		public SingletonMap KEY_VALUE_GENERIC_TYPE copy() { return new SingletonMapKV_BRACES(key, value); }
 		@Override
@@ -363,8 +382,20 @@ public class MAPS
 		public VALUE_TYPE GET_VALUE(KEY_TYPE key) { return getDefaultReturnValue(); }
 #if !TYPE_OBJECT || !VALUE_OBJECT
 		@Override
-		public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return EMPTY_VALUE; }
+		public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return defaultValue; }
 #endif
+		@Override
+		public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public void BULK_MERGE(MAP KEY_VALUE_GENERIC_TYPE m, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
 		@Override
 		public SET KEY_GENERIC_TYPE keySet() { return SETS.empty(); }
 		@Override
@@ -408,10 +439,12 @@ public class MAPS
 		}
 		
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap() { return MAPS.synchronize(map.descendingMap()); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap() { return MAPS.unmodifiable(map.descendingMap()); }
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE navigableKeySet() { return SETS.unmodifiable(map.navigableKeySet()); }
 		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE keySet() { return SETS.unmodifiable(map.keySet()); }
+		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE descendingKeySet() { return SETS.unmodifiable(map.descendingKeySet()); }
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { return MAPS.unmodifiable(map.firstEntry()); }
@@ -460,7 +493,7 @@ public class MAPS
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE ceilingEntry(KEY_TYPE key) { return MAPS.unmodifiable(map.ceilingEntry(key)); }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE copy() { return map.copy(); }
 	}
 	
 	/**
@@ -491,17 +524,28 @@ public class MAPS
 		@Override
 		public KEY_TYPE FIRST_ENTRY_KEY() { return map.FIRST_ENTRY_KEY(); }
 		@Override
-		public KEY_TYPE POLL_FIRST_ENTRY_KEY() { return map.POLL_FIRST_ENTRY_KEY(); }
+		public KEY_TYPE POLL_FIRST_ENTRY_KEY() { throw new UnsupportedOperationException(); }
 		@Override
 		public KEY_TYPE LAST_ENTRY_KEY() { return map.LAST_ENTRY_KEY(); }
 		@Override
-		public KEY_TYPE POLL_LAST_ENTRY_KEY() { return map.POLL_LAST_ENTRY_KEY(); }
+		public KEY_TYPE POLL_LAST_ENTRY_KEY() { throw new UnsupportedOperationException(); }
 		@Override
 		public VALUE_TYPE FIRST_ENTRY_VALUE() { return map.FIRST_ENTRY_VALUE(); }
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); }
 		@Override
-		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { return map.copy(); }
+		@Override
+		public ORDERED_SET KEY_GENERIC_TYPE keySet() { 
+			if(keys == null) keys = SETS.unmodifiable(map.keySet()); 
+			return (ORDERED_SET KEY_GENERIC_TYPE)keys;
+		}
+				
+		@Override
+		public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
+			if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySetKV_BRACES(map.ENTRY_SET());
+			return (ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySet;
+		}
 	}
 	
 	/**
@@ -526,19 +570,21 @@ public class MAPS
 		@Override
 		public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { return MAPS.unmodifiable(map.tailMap(fromKey)); }
 		@Override
+		public SORTED_SET KEY_GENERIC_TYPE keySet() { return SETS.unmodifiable(map.keySet()); }
+		@Override
 		public KEY_TYPE FIRST_ENTRY_KEY() { return map.FIRST_ENTRY_KEY(); }
 		@Override
-		public KEY_TYPE POLL_FIRST_ENTRY_KEY() { return map.POLL_FIRST_ENTRY_KEY(); }
+		public KEY_TYPE POLL_FIRST_ENTRY_KEY() { throw new UnsupportedOperationException(); }
 		@Override
 		public KEY_TYPE LAST_ENTRY_KEY() { return map.LAST_ENTRY_KEY(); }
 		@Override
-		public KEY_TYPE POLL_LAST_ENTRY_KEY() { return map.POLL_LAST_ENTRY_KEY(); }
+		public KEY_TYPE POLL_LAST_ENTRY_KEY() { throw new UnsupportedOperationException(); }
 		@Override
 		public VALUE_TYPE FIRST_ENTRY_VALUE() { return map.FIRST_ENTRY_VALUE(); }
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); }
 		@Override
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE copy() { return map.copy(); }
 	}
 	
 	/**
@@ -575,13 +621,34 @@ public class MAPS
 		public boolean remove(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
 #endif
 		@Override
-		public VALUE_TYPE GET_VALUE(KEY_TYPE key) { return map.GET_VALUE(key); }
+		public VALUE_TYPE GET_VALUE(KEY_TYPE key) {
+			VALUE_TYPE type = map.GET_VALUE(key);
+			return VALUE_EQUALS(type, map.getDefaultReturnValue()) && !map.containsKey(key) ? getDefaultReturnValue() : type;
+		}
 #if !TYPE_OBJECT || !VALUE_OBJECT
 		@Override
 		public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.getOrDefault(key, defaultValue); }
 #endif
 		@Override
-		public MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public void BULK_MERGE(MAP KEY_VALUE_GENERIC_TYPE m, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public void REPLACE_VALUES(UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { throw new UnsupportedOperationException(); }
+		@Override
+		public void REPLACE_VALUES(MAP KEY_VALUE_GENERIC_TYPE m) { throw new UnsupportedOperationException(); }
+		@Override
+		public MAP KEY_VALUE_GENERIC_TYPE copy() { return map.copy(); }
+		@Override
+		public void clear() { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public SET KEY_GENERIC_TYPE keySet() { 
@@ -602,6 +669,45 @@ public class MAPS
 		}
 	}
 	
+	
+	/**
+	 * The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
+	 * @Type(T)
+	 * @ValueType(V)
+	 */
+	public static class UnmodifyableOrderedEntrySet KEY_VALUE_GENERIC_TYPE extends UnmodifyableEntrySet KEY_VALUE_GENERIC_TYPE implements ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>
+	{
+		ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> set;
+		
+		UnmodifyableOrderedEntrySet(ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> c) {
+			super(c);
+			set = c;
+		}
+
+		@Override
+		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public boolean addAndMoveToLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public boolean moveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public boolean moveToLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> copy() { return set.copy(); }
+		@Override
+		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { return ObjectIterators.unmodifiable(set.iterator()); }
+		@Override
+		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); }
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { return set.first(); }
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { throw new UnsupportedOperationException(); }
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { return set.last(); }
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { throw new UnsupportedOperationException(); }
+	}
+	
 	/**
 	 * The Unmodifyable Set implementation for the Unmodifyable Map implementation
 	 * @Type(T)
@@ -660,9 +766,11 @@ public class MAPS
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE descendingKeySet() { synchronized(mutex) { return SETS.synchronize(map.descendingKeySet(), mutex); } }
 		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE keySet() { synchronized(mutex) { return SETS.synchronize(map.keySet(), mutex); } }
+		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { synchronized(mutex) { return map.firstEntry(); } }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { synchronized(mutex) { return map.firstEntry(); } }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { synchronized(mutex) { return map.lastEntry(); } }
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } }
 		@Override
@@ -696,8 +804,8 @@ public class MAPS
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE ceilingEntry(KEY_TYPE key) { synchronized(mutex) { return map.ceilingEntry(key); } }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE copy() { synchronized(mutex) { return map.copy(); } }
-		#if !TYPE_OBJECT
+#if !TYPE_OBJECT
 		@Override
 		@Deprecated
 		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, boolean fromInclusive, CLASS_TYPE toKey, boolean toInclusive) { synchronized(mutex) { return MAPS.synchronize(map.subMap(fromKey, fromInclusive, toKey, toInclusive), mutex); } }
@@ -794,7 +902,18 @@ public class MAPS
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() { synchronized(mutex) { return map.LAST_ENTRY_VALUE(); } }
 		@Override
-		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { synchronized(mutex) { return map.copy(); } }
+		@Override
+		public ORDERED_SET KEY_GENERIC_TYPE keySet() {
+			if(keys == null) keys = SETS.synchronize(map.keySet(), mutex);
+			return (ORDERED_SET KEY_GENERIC_TYPE)keys;
+		}
+		
+		@Override
+		public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
+			if(entrySet == null) entrySet = ObjectSets.synchronize(map.ENTRY_SET(), mutex);
+			return (ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySet;
+		}
 	}
 	
 	/**
@@ -824,6 +943,8 @@ public class MAPS
 		@Override
 		public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { synchronized(mutex) { return MAPS.synchronize(map.tailMap(fromKey), mutex); } }
 		@Override
+		public SORTED_SET KEY_GENERIC_TYPE keySet() { synchronized(mutex) { return SETS.synchronize(map.keySet(), mutex); } }
+		@Override
 		public KEY_TYPE FIRST_ENTRY_KEY() { synchronized(mutex) { return map.FIRST_ENTRY_KEY(); } }
 		@Override
 		public KEY_TYPE POLL_FIRST_ENTRY_KEY() { synchronized(mutex) { return map.POLL_FIRST_ENTRY_KEY(); } }
@@ -836,7 +957,7 @@ public class MAPS
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() { synchronized(mutex) { return map.LAST_ENTRY_VALUE(); } }
 		@Override
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE copy() { synchronized(mutex) { return map.copy(); } }
 #if !TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -940,6 +1061,8 @@ public class MAPS
 		@Override
 		public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { synchronized(mutex) { return map.COMPUTE_IF_PRESENT(key, mappingFunction); } }
 		@Override
+		public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) { synchronized(mutex) { return map.SUPPLY_IF_ABSENT(key, valueProvider); } }
+		@Override
 		public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { synchronized(mutex) { return map.MERGE(key, value, mappingFunction); } }
 		@Override
 		public void BULK_MERGE(MAP KEY_VALUE_GENERIC_TYPE m, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { synchronized(mutex) { map.BULK_MERGE(m, mappingFunction); } }
@@ -950,9 +1073,9 @@ public class MAPS
 		@Override
 		public void forEach(BI_CONSUMER KEY_VALUE_GENERIC_TYPE action) { synchronized(mutex) { map.forEach(action); } }
 		@Override
-		public int size() { synchronized(mutex) { return super.size(); } }
+		public int size() { synchronized(mutex) { return map.size(); } }
 		@Override
-		public MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public MAP KEY_VALUE_GENERIC_TYPE copy() { synchronized(mutex) { return map.copy(); } }
 		@Override
 		public SET KEY_GENERIC_TYPE keySet() {
 			if(keys == null) keys = SETS.synchronize(map.keySet(), mutex);