Update README.md

- Added: addOrGet for sets.
- Added: Async API which allows to easily execute Iterables/Collections
offthread without the complexity.

.github/workflows/build_validator.yml

@@ -0,0 +1,36 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: Latest Build
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK 11
+      uses: actions/setup-java@v1
+      with:
+        java-version: '11'
+        distribution: 'adopt'
+        cache: gradle
+    - name: Validate Gradle wrapper
+      uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
+    - name: Make gradlew executable
+      run: chmod +x ./gradlew
+    - name: Generate SourceCode with Gradle
+      run: ./gradlew generateGithubSource
+    - name: Build with Gradle
+      run: ./gradlew build

.gitignore

@@ -1,7 +1,6 @@
 # ---> Gradle
 .gradle
 /build/
-gradle.properties
 
 # Ignore Gradle GUI config
 gradle-app.setting

Changelog.md

@@ -1,5 +1,29 @@
 # Changelog of versions
 
+### Version 0.6.0
+- Added: addOrGet for sets.
+- Added: Async API which allows to easily execute Iterables/Collections offthread without the complexity.
+
+### Version 0.5.3
+- Added: OrderedMap/Set
+- Added: Deprecation to Functions that are specific to Ordered interfaces in the SortedMap/Set
+- Added: subFrom to Maps which is the counterpart of the addTo method
+- Added: pourAsList and pourAsSet (booleans excluded for sets) to Iterable
+- Fixed: ArrayList.grow had a small bug where it would trigger to early causing performance problems with exact sized collections.
+- Fixed: FIFOQueue size constructor had a small bug where it would trigger a array enlargement when all elements were inserted.
+
+### Version 0.5.2
+- Fixed: Bugs with Queues starting with the wrong size
+- Fixed: ArrayGrowth for Queues was +1 instead of +50%
+- Added: Benchmarks with java and FastUtil
+
+### Version 0.5.1
+- Fixed: Reworked the NavigableSet/Map implementations of RBTree/AVLTree/Array Sets/Maps so they are now deemed stable.
+- Added: Another 150k Unit tests.
+- Added: List and Set Unit tests for Integer (or Primitives in this case) to ensure basic stability there. (Now covering all sets and lists)
+- Fixed: Bugs with null values for primitive collections.
+- Removed: ArraySet/Map subSet/subMap implementation was removed.
+
 ### Version 0.5.0
 - Added: 2 Helper functions to find out how many bits are required to store a Number.
 - Added: pour function directly into Iterable which allows to collect all elements in the Iterable directly.

LICENSE

@@ -1,208 +1,201 @@
-Apache License
+                                 Apache License
+                           Version 2.0, December 2021
+                        http://www.apache.org/licenses/
 
-Version 2.0, January 2021
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION,
-AND DISTRIBUTION
 
    1. Definitions.
 
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
 
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
 
-"License" shall mean the terms and conditions for use, reproduction, and distribution
+      "Legal Entity" shall mean the union of the acting entity and all
-as defined by Sections 1 through 9 of this document.
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
 
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
 
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
 
-"Licensor" shall mean the copyright owner or entity authorized by the copyright
+      "Object" form shall mean any form resulting from mechanical
-owner that is granting the License.
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
 
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
 
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
 
-"Legal Entity" shall mean the union of the acting entity and all other entities
+      "Contribution" shall mean any work of authorship, including
-that control, are controlled by, or are under common control with that entity.
+      the original version of the Work and any modifications or additions
-For the purposes of this definition, "control" means (i) the power, direct
+      to that Work or Derivative Works thereof, that is intentionally
-or indirect, to cause the direction or management of such entity, whether
+      submitted to Licensor for inclusion in the Work by the copyright owner
-by contract or otherwise, or (ii) ownership of fifty percent (50%) or more
+      or by an individual or Legal Entity authorized to submit on behalf of
-of the outstanding shares, or (iii) beneficial ownership of such entity.
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
 
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
 
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
 
-"You" (or "Your") shall mean an individual or Legal Entity exercising permissions
+   3. Grant of Patent License. Subject to the terms and conditions of
-granted by this License.
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
 
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
 
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
 
-"Source" form shall mean the preferred form for making modifications, including
+      (b) You must cause any modified files to carry prominent notices
-but not limited to software source code, documentation source, and configuration
+          stating that You changed the files; and
-files.
 
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
 
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
 
-"Object" form shall mean any form resulting from mechanical transformation
+      You may add Your own copyright statement to Your modifications and
-or translation of a Source form, including but not limited to compiled object
+      may provide additional or different license terms and conditions
-code, generated documentation, and conversions to other media types.
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
 
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
 
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
 
-"Work" shall mean the work of authorship, whether in Source or Object form,
+   7. Disclaimer of Warranty. Unless required by applicable law or
-made available under the License, as indicated by a copyright notice that
+      agreed to in writing, Licensor provides the Work (and each
-is included in or attached to the work (an example is provided in the Appendix
+      Contributor provides its Contributions) on an "AS IS" BASIS,
-below).
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
 
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
 
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
 
-"Derivative Works" shall mean any work, whether in Source or Object form,
+   END OF TERMS AND CONDITIONS
-that is based on (or derived from) the Work and for which the editorial revisions,
-annotations, elaborations, or other modifications represent, as a whole, an
-original work of authorship. For the purposes of this License, Derivative
-Works shall not include works that remain separable from, or merely link (or
-bind by name) to the interfaces of, the Work and Derivative Works thereof.
 
+   APPENDIX: How to apply the Apache License to your work.
 
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
 
-"Contribution" shall mean any work of authorship, including the original version
+   Copyright 2021 Speiger
-of the Work and any modifications or additions to that Work or Derivative
-Works thereof, that is intentionally submitted to Licensor for inclusion in
-the Work by the copyright owner or by an individual or Legal Entity authorized
-to submit on behalf of the copyright owner. For the purposes of this definition,
-"submitted" means any form of electronic, verbal, or written communication
-sent to the Licensor or its representatives, including but not limited to
-communication on electronic mailing lists, source code control systems, and
-issue tracking systems that are managed by, or on behalf of, the Licensor
-for the purpose of discussing and improving the Work, but excluding communication
-that is conspicuously marked or otherwise designated in writing by the copyright
-owner as "Not a Contribution."
 
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
 
+       http://www.apache.org/licenses/LICENSE-2.0
 
-"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+   Unless required by applicable law or agreed to in writing, software
-of whom a Contribution has been received by Licensor and subsequently incorporated
+   distributed under the License is distributed on an "AS IS" BASIS,
-within the Work.
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
+   See the License for the specific language governing permissions and
-2. Grant of Copyright License. Subject to the terms and conditions of this
+   limitations under the License.
-License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable copyright license to reproduce, prepare
-Derivative Works of, publicly display, publicly perform, sublicense, and distribute
-the Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of this License,
-each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section) patent
-license to make, have made, use, offer to sell, sell, import, and otherwise
-transfer the Work, where such license applies only to those patent claims
-licensable by such Contributor that are necessarily infringed by their Contribution(s)
-alone or by combination of their Contribution(s) with the Work to which such
-Contribution(s) was submitted. If You institute patent litigation against
-any entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that the Work or a Contribution incorporated within the Work constitutes direct
-or contributory patent infringement, then any patent licenses granted to You
-under this License for that Work shall terminate as of the date such litigation
-is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the Work or
-Derivative Works thereof in any medium, with or without modifications, and
-in Source or Object form, provided that You meet the following conditions:
-
-(a) You must give any other recipients of the Work or Derivative Works a copy
-of this License; and
-
-(b) You must cause any modified files to carry prominent notices stating that
-You changed the files; and
-
-(c) You must retain, in the Source form of any Derivative Works that You distribute,
-all copyright, patent, trademark, and attribution notices from the Source
-form of the Work, excluding those notices that do not pertain to any part
-of the Derivative Works; and
-
-(d) If the Work includes a "NOTICE" text file as part of its distribution,
-then any Derivative Works that You distribute must include a readable copy
-of the attribution notices contained within such NOTICE file, excluding those
-notices that do not pertain to any part of the Derivative Works, in at least
-one of the following places: within a NOTICE text file distributed as part
-of the Derivative Works; within the Source form or documentation, if provided
-along with the Derivative Works; or, within a display generated by the Derivative
-Works, if and wherever such third-party notices normally appear. The contents
-of the NOTICE file are for informational purposes only and do not modify the
-License. You may add Your own attribution notices within Derivative Works
-that You distribute, alongside or as an addendum to the NOTICE text from the
-Work, provided that such additional attribution notices cannot be construed
-as modifying the License.
-
-You may add Your own copyright statement to Your modifications and may provide
-additional or different license terms and conditions for use, reproduction,
-or distribution of Your modifications, or for any such Derivative Works as
-a whole, provided Your use, reproduction, and distribution of the Work otherwise
-complies with the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise, any
-Contribution intentionally submitted for inclusion in the Work by You to the
-Licensor shall be under the terms and conditions of this License, without
-any additional terms or conditions. Notwithstanding the above, nothing herein
-shall supersede or modify the terms of any separate license agreement you
-may have executed with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade names,
-trademarks, service marks, or product names of the Licensor, except as required
-for reasonable and customary use in describing the origin of the Work and
-reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or agreed to
-in writing, Licensor provides the Work (and each Contributor provides its
-Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied, including, without limitation, any warranties
-or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR
-A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness
-of using or redistributing the Work and assume any risks associated with Your
-exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory, whether
-in tort (including negligence), contract, or otherwise, unless required by
-applicable law (such as deliberate and grossly negligent acts) or agreed to
-in writing, shall any Contributor be liable to You for damages, including
-any direct, indirect, special, incidental, or consequential damages of any
-character arising as a result of this License or out of the use or inability
-to use the Work (including but not limited to damages for loss of goodwill,
-work stoppage, computer failure or malfunction, or any and all other commercial
-damages or losses), even if such Contributor has been advised of the possibility
-of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing the Work
-or Derivative Works thereof, You may choose to offer, and charge a fee for,
-acceptance of support, warranty, indemnity, or other liability obligations
-and/or rights consistent with this License. However, in accepting such obligations,
-You may act only on Your own behalf and on Your sole responsibility, not on
-behalf of any other Contributor, and only if You agree to indemnify, defend,
-and hold each Contributor harmless for any liability incurred by, or claims
-asserted against, such Contributor by reason of your accepting any such warranty
-or additional liability. END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-To apply the Apache License to your work, attach the following boilerplate
-notice, with the fields enclosed by brackets "[]" replaced with your own identifying
-information. (Don't include the brackets!) The text should be enclosed in
-the appropriate comment syntax for the file format. We also recommend that
-a file or class name and description of purpose be included on the same "printed
-page" as the copyright notice for easier identification within third-party
-archives.
-
-Copyright 2021 Speiger
-
-Licensed under the Apache License, Version 2.0 (the "License");
-
-you may not use this file except in compliance with the License.
-
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-
-distributed under the License is distributed on an "AS IS" BASIS,
-
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
-See the License for the specific language governing permissions and
-
-limitations under the License.

README.md

@@ -1,3 +1,5 @@
+![build](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_validator.yml/badge.svg)
+
 # Primitive-Collections
 
 This is a Simple Primitive Collections Library i started as a hobby Project.     
@@ -6,11 +8,11 @@ But its focus is a different one.
 
 ## Main Features:      
 - ArrayLists / LinkedLists
-- HashSet/Map (Linked & HashControl)
+- HashSets/Maps (Linked & HashControl)
-- TreeSet/Map (RB & AVL)
+- TreeSets/Maps (RB & AVL)
-- EnumMap
+- EnumMaps
 - Immutable Maps/Lists/Sets
-- Priority Queue
+- Priority Queues
 - Streams & Functional Queries
 - SplitIterators
 - Iterators
@@ -22,17 +24,13 @@ But its focus is a different one.
 
 ## 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 16000 test covering Maps/Sets/Lists.     
+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.     
 
-One know aspect of Instability is SubSets and SubMaps. They require full rewrites to be fully stable.     
+### Benchmarks
-So it is not advised to use them until these issues are addressed.     
+Benchmarks can be found here: [Click Me](https://github.com/Speiger/Primitive-Collections-Benchmarks/tree/master)
-PriorityQueues are tested separately and ensure basic functionality though GuavaTests are planned.     
-They just require a custom test implementation.     
-
-As a summary: Stability is good/excellent, unless you need SubSets/SubMaps     
 
 ## Specialized Functions
 New Specialized functions that were added to increase performance or reduce allocations or Quality Of life.
@@ -47,6 +45,7 @@ To highlight things that may be wanted.
 	- 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.
@@ -66,6 +65,7 @@ To highlight things that may be wanted.
 	- 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.
@@ -95,13 +95,16 @@ repositories {
     }
 }
 dependencies {
-	compile 'de.speiger:Primitive-Collections:0.5.0'
+	compile 'de.speiger:Primitive-Collections:0.5.3'
 }
 ```
 Direct:
 
 | Version 	| Jar                                                                                                                          	| Sources                                                                                                                              	| Java Doc                                                                                                                             	|
 |---------	|------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|
+| 0.5.3   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3-javadoc.jar) 	|
+| 0.5.2   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2-javadoc.jar) 	|
+| 0.5.1   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1-javadoc.jar) 	|
 | 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) 	|
@@ -134,5 +137,4 @@ to build the jar:
 do not combine the commands because they can not be executed at the same time.      
 
 ## Current Down Sides (Random order)
-- SubMaps/Set implementation isn't perfect right now. This will be addressed slowly due to rewrites required.     
 - 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.5.0';
+version = '0.5.3';
 
 sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8'
 
@@ -42,11 +42,10 @@ configurations {
 }
 
 dependencies {
-	builderCompile 'de.speiger:Simple-Code-Generator:1.0.5'
+	builderCompile 'de.speiger:Simple-Code-Generator:1.0.6'
-	runtimeOnly 'de.speiger:Simple-Code-Generator:1.0.5'
+	runtimeOnly 'de.speiger:Simple-Code-Generator:1.0.6'
     testImplementation 'junit:junit:4.12'
     testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
-    
 }
 
 task generateSource(type: JavaExec) {
@@ -56,6 +55,14 @@ task generateSource(type: JavaExec) {
  	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
 }
 
+task generateGithubSource(type: JavaExec) {
+	group = 'internal'
+	description = 'Builds the sourcecode for Github Actions'
+ 	classpath = sourceSets.builder.runtimeClasspath
+ 	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
+ 	args = ['false', 'true']
+}
+
 task forceGenerateSource(type: JavaExec) {
 	group = 'internal'
 	description = 'Builds the sourcecode forceful'
@@ -88,12 +95,17 @@ test {
 }
 
 uploadArchives {
+	Properties props = new Properties()
+	if(file("$buildDir/credentials.properties").exists())
+	{
+		props.load(new FileInputStream("$buildDir/credentials.properties"))
+	}
 	repositories.mavenDeployer {
 		repository(url: 'https://maven.speiger.com/repository/main') {
-			authentication(userName: project.properties.mavenUser, password: project.properties.mavenPassword)
+			authentication(userName: props.mavenUser, password: props.mavenPassword)
 		}
 		snapshotRepository(url: 'https://maven.speiger.com/repository/main') {
-			authentication(userName: project.properties.mavenUser, password: project.properties.mavenPassword)
+			authentication(userName: props.mavenUser, password: props.mavenPassword)
 		}
 		pom {
 			version = project.version

gradle.properties

@@ -0,0 +1 @@
+org.gradle.jvmargs=-Xmx3G

src/builder/java/speiger/src/builder/GlobalVariables.java

@@ -158,6 +158,7 @@ public class GlobalVariables
 		
 		//Final Classes
 		addClassMapper("ARRAY_LIST", "ArrayList");
+		addClassMapper("ASYNC_BUILDER", "AsyncBuilder");
 		addClassMapper("LINKED_LIST", "LinkedList");
 		addAbstractMapper("IMMUTABLE_LIST", "Immutable%sList");
 		addClassMapper("ARRAY_FIFO_QUEUE", "ArrayFIFOQueue");
@@ -191,6 +192,7 @@ public class GlobalVariables
 		addAbstractMapper("ABSTRACT_LIST", "Abstract%sList");
 		addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
 		addClassMapper("SUB_LIST", "SubList");
+		addAbstractMapper("BASE_TASK", "Base%sTask");
 		
 		//Helper Classes
 		addClassMapper("LISTS", "Lists");
@@ -218,6 +220,7 @@ public class GlobalVariables
 		addClassMapper("LIST_ITER", "ListIter");
 		addClassMapper("LIST", "List");
 		addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
+		addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
 		addBiClassMapper("SORTED_MAP", "SortedMap", "2");
 		addBiClassMapper("MAP", "Map", "2");
 		addClassMapper("NAVIGABLE_SET", "NavigableSet");
@@ -226,11 +229,13 @@ public class GlobalVariables
 		addClassMapper("PRIORITY_DEQUEUE", "PriorityDequeue");
 		addClassMapper("PREDICATE", "2BooleanFunction");
 		addClassMapper("SORTED_SET", "SortedSet");
+		addClassMapper("ORDERED_SET", "OrderedSet");
 		addClassMapper("SET", "Set");
 		addClassMapper("STRATEGY", "Strategy");
 		addClassMapper("STACK", "Stack");
 		addClassMapper("SUPPLIER", "Supplier");
 		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
+		addClassMapper("TASK", "Task");
 		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");
 		if(type.isObject())
 		{

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

@@ -29,12 +29,22 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	
 	public PrimitiveCollectionsBuilder()
 	{
-		super(Paths.get("src/builder/resources/speiger/assets/collections/templates/"), Paths.get("src/main/java/speiger/src/collections/"), Paths.get("src/builder/resources/speiger/assets/collections/"));
+		this(false);
+	}
+	
+	public PrimitiveCollectionsBuilder(boolean silencedSuccess)
+	{
+		super(silencedSuccess, Paths.get("src/builder/resources/speiger/assets/collections/templates/"), Paths.get("src/main/java/speiger/src/collections/"), Paths.get("src/builder/resources/speiger/assets/collections/"));
 	}
 	
 	public PrimitiveCollectionsBuilder(Path sourceFolder, Path outputFolder, Path dataFolder)
 	{
-		super(sourceFolder, outputFolder, dataFolder);
+		this(false, sourceFolder, outputFolder, dataFolder);
+	}
+	
+	public PrimitiveCollectionsBuilder(boolean silencedSuccess, Path sourceFolder, Path outputFolder, Path dataFolder)
+	{
+		super(silencedSuccess, sourceFolder, outputFolder, dataFolder);
 	}
 	
 	@Override
@@ -73,7 +83,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		biRequired.put("Pair", "");
 		biRequired.put("MutablePair", "");
 		biRequired.put("ImmutablePair", "");
-		addBiClass("Function", "Maps", "Map", "SortedMap", "NavigableMap", "AbstractMap", "ImmutableOpenHashMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
+		addBiClass("Function", "Maps", "Map", "SortedMap", "OrderedMap", "NavigableMap", "AbstractMap", "ImmutableOpenHashMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
 		nameRemapper.put("BiConsumer", "%sConsumer");
 		nameRemapper.put("IArray", "I%sArray");
 		nameRemapper.put("AbstractMap", "Abstract%sMap");
@@ -88,8 +98,8 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		nameRemapper.put("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
 		
 		addBlockage(ClassType.OBJECT, "Consumer", "Comparator", "Stack");
-		addBlockage(ClassType.BOOLEAN, "ArraySet", "AVLTreeSet", "RBTreeSet", "SortedSet", "NavigableSet", "OpenHashSet", "OpenCustomHashSet", "LinkedOpenHashSet", "LinkedOpenCustomHashSet");
+		addBlockage(ClassType.BOOLEAN, "ArraySet", "AVLTreeSet", "RBTreeSet", "SortedSet", "OrderedSet", "NavigableSet", "OpenHashSet", "OpenCustomHashSet", "LinkedOpenHashSet", "LinkedOpenCustomHashSet");
-		addBlockage(ClassType.BOOLEAN, "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "NavigableMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
+		addBlockage(ClassType.BOOLEAN, "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "OrderedMap", "NavigableMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
 	}
 	
 	protected void create(ClassType mainType, ClassType subType) 
@@ -159,10 +169,14 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	            new PrimitiveCollectionsBuilder().process(false);
 	        } else if(args.length == 1) {
 	            new PrimitiveCollectionsBuilder().process(Boolean.parseBoolean(args[0]));
+	        } else if(args.length == 2) {
+	            new PrimitiveCollectionsBuilder(Boolean.parseBoolean(args[1])).process(Boolean.parseBoolean(args[0]));
 	        } else if(args.length == 3) {
 	            new PrimitiveCollectionsBuilder(Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(false);
 	        } else if(args.length == 4) {
-	            new PrimitiveCollectionsBuilder(Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
+	            new PrimitiveCollectionsBuilder(false, Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
+	        } else if(args.length == 4) {
+	            new PrimitiveCollectionsBuilder(Boolean.parseBoolean(args[4]), Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
 	        } else {
 	            System.out.println("Invalid argument count passed in");
 	            System.exit(1);

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

@@ -15,6 +15,13 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+#if !TYPE_BOOLEAN
+import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
+#endif
+import speiger.src.collections.PACKAGE.utils.ASYNC_BUILDER;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 import speiger.src.collections.PACKAGE.utils.ITERABLES;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -83,6 +90,16 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	@Override
 	default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createUnknownSplititerator(iterator(), 0); }
 	
+	/**
+	 * Creates a Async Builder for moving work of the thread.
+	 * It is not designed to split the work to multithreaded work, so using this keep it singlethreaded, but it allows to be moved to another thread.
+	 * @see ASYNC_BUILDER
+	 * @return a AsyncBuilder
+	 */
+	default ASYNC_BUILDER KEY_GENERIC_TYPE asAsync() {
+		return new ASYNC_BUILDERBRACES(this);
+	}
+
 	/**
 	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
 	 * @param mapper the mapping function
@@ -160,6 +177,24 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 		return collection;
 	}
 	
+	/**
+	 * A Helper function that reduces the usage of streams and allows to collect all elements as a ArrayList
+	 * @return a new ArrayList of all elements
+	 */
+	default LIST KEY_GENERIC_TYPE pourAsList() {
+		return pour(new ARRAY_LISTBRACES()); 
+	}
+	
+#if !TYPE_BOOLEAN
+	/**
+	 * A Helper function that reduces the usage of streams and allows to collect all elements as a LinkedHashSet
+	 * @return a new LinkedHashSet of all elements
+	 */
+	default SET KEY_GENERIC_TYPE pourAsSet() { 
+		return pour(new LINKED_HASH_SETBRACES()); 		
+	}
+	
+#endif
 	/**
 	 * Helper function to reduce stream usage that allows to filter for any matches.
 	 * @param filter that should be applied

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

@@ -0,0 +1,92 @@
+package speiger.src.collections.PACKAGE.functions;
+
+import java.util.concurrent.RunnableFuture;
+#if !TYPE_OBJECT
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+#endif
+
+/**
+ * 
+ * A Type Specific Task interface that allows you to keep track of the task that is currently running.<br>
+ * It extends Runnable future and supports said functions but also provides quality of life functions like:<br>
+ * 
+ * - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed.
+ * - pause/resume: which allows to pause/resume the task at any moment, making it easier to create thread-safe actions.
+ * @Type(T)
+ */
+public interface TASK KEY_GENERIC_TYPE extends RunnableFuture<CLASS_TYPE> {
+	/**
+	 * Helper function to detect if the task is currently paused.
+	 * @return true if paused
+	 */
+	public boolean isPaused();
+	
+	/**
+	 * Pauses the task, which lets the thread finish without completing the task.
+	 * Tasks are written in the way where they can pause without any issues.
+	 * This won't be instant, as this function is applied asynchronous and doesn't check if the thread paused.
+	 * So make sure it had the time to pause.
+	 */
+	public void pause();
+	
+	/**
+	 * Pauses the task, which lets the thread finish without completing the task.
+	 * Tasks are written in the way where they can pause without any issues.
+	 * This won't be instant, as this function is applied asynchronous.
+	 * It will await the pausing of the task.
+	 */
+	public void awaitPausing();
+	
+	/**
+	 * Continues the task if it wasn't already completed.
+	 * This is done by resubmitting the task to the executor provided.
+	 */
+	public void resume();
+	
+	/**
+	 * Quality of life function that allows to detect if no cancellation/exception was applied to this task and it completed on its own.
+	 * @return true if it was properly completed
+	 */
+	public boolean isSuccessful();
+	
+#if !TYPE_OBJECT
+	/**
+	 * A Type Specific get method that allows to reduce (un)boxing of primtives.
+	 * 
+	 * Waits if necessary for the computation to complete, and then
+	 * retrieves its result.
+	 *
+	 * @return the computed result as primitive
+	 * @throws CancellationException if the computation was cancelled
+	 * @throws ExecutionException if the computation threw an exception
+	 * @throws InterruptedException if the current thread was interrupted
+	 * while waiting
+	 */
+	public KEY_TYPE GET_KEY() throws InterruptedException, ExecutionException;
+
+	/**
+	 * Waits if necessary for at most the given time for the computation
+	 * to complete, and then retrieves its result, if available.
+	 *
+	 * @param timeout the maximum time to wait
+	 * @param unit the time unit of the timeout argument
+	 * @return the computed result as primitive
+	 * @throws CancellationException if the computation was cancelled
+	 * @throws ExecutionException if the computation threw an exception
+	 * @throws InterruptedException if the current thread was interrupted while waiting
+	 * @throws TimeoutException if the wait timed out
+	 */
+	public KEY_TYPE GET_KEY(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
+	
+	@Override
+	@Deprecated
+	public default CLASS_TYPE get() throws InterruptedException, ExecutionException { return KEY_TO_OBJ(GET_KEY()); }
+	
+	@Override
+	@Deprecated
+	public default CLASS_TYPE get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return KEY_TO_OBJ(GET_KEY(timeout, unit)); }
+#endif
+}

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

@@ -232,6 +232,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	 * @param index the index where to append the elements to
 	 * @param c the elements to append to the list
 	 * @throws IndexOutOfBoundsException if index is outside of the lists range
+	 * @throws NullPointerException if collection contains a null element
 	 */
 	@Override
 	@Primitive
@@ -239,6 +240,9 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		if(c instanceof COLLECTION) return addAll(index, (COLLECTION KEY_GENERIC_TYPE)c);
 		int add = c.size();
 		if(add <= 0) return false;
+#if !TYPE_OBJECT
+		if(c.contains(null)) throw new NullPointerException();
+#endif
 		grow(size + add);
 		if(index != size) System.arraycopy(data, index, data, index+add, size - index);
 		size+=add;
@@ -1126,7 +1130,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	}
 	
 	protected void grow(int capacity) {
-		if(capacity < data.length) return;
+		if(capacity <= data.length) return;
 		data = Arrays.copyOf(data, data == ARRAYS.EMPTY_ARRAY ? Math.max(DEFAULT_ARRAY_SIZE, capacity) : (int)Math.max(Math.min((long)data.length + (data.length >> 1), SanityChecks.MAX_ARRAY_SIZE), capacity));		
 	}
 	

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

@@ -21,6 +21,7 @@ import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.SORTED_SET;
@@ -71,7 +72,7 @@ import speiger.src.collections.utils.HashUtil;
  * @Type(T)
  * @ValueType(V) 
  */
-public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;

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

@@ -286,6 +286,15 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		return oldValue;
 	}
 	
+	@Override
+	public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) {
+		int slot = findIndex(key);
+		if(slot < 0) return getDefaultReturnValue();
+		VALUE_TYPE oldValue = values[slot];
+		values[slot] -= value;
+		if(value < 0 ? (values[slot] >= getDefaultReturnValue()) : (values[slot] <= getDefaultReturnValue())) removeIndex(slot);
+		return oldValue;
+	}
 #endif
 #if !TYPE_OBJECT
 	@Override

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

@@ -22,6 +22,7 @@ import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.SORTED_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
@@ -70,7 +71,7 @@ import speiger.src.collections.utils.HashUtil;
  * @Type(T)
  * @ValueType(V)
  */
-public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;

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

@@ -261,6 +261,15 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		return oldValue;
 	}
 	
+	@Override
+	public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) {
+		int slot = findIndex(key);
+		if(slot < 0) return getDefaultReturnValue();
+		VALUE_TYPE oldValue = values[slot];
+		values[slot] -= value;
+		if(value < 0 ? (values[slot] >= getDefaultReturnValue()) : (values[slot] <= getDefaultReturnValue())) removeIndex(slot);
+		return oldValue;
+	}
 #endif
 #if !TYPE_OBJECT
 	@Override

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

@@ -25,6 +25,7 @@ import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 #endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.sets.SORTED_SET;
@@ -84,7 +85,7 @@ import speiger.src.collections.utils.SanityChecks;
  * @Type(T)
  * @ValueType(V)
  */
-public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE
+public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing keys array */
 	protected transient KEY_TYPE[] keys;
@@ -297,11 +298,11 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
 	@Override
 	public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }	
-	
 #if VALUE_PRIMITIVES
 	@Override
 	public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	
+	@Override
+	public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }	
 #endif
 	@Override
 	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }

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

@@ -180,6 +180,18 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 		return getDefaultReturnValue();
 	}
 	
+	@Override
+	public VALUE_TYPE subFrom(T key, VALUE_TYPE value) {
+		int index = key.ordinal();
+		if(!isSet(index)) return getDefaultReturnValue();
+		VALUE_TYPE oldValue = values[index];
+		values[index] -= value;
+		if(value < 0 ? (values[index] >= getDefaultReturnValue()) : (values[index] <= getDefaultReturnValue())) {
+			clear(index);
+			values[index] = EMPTY_VALUE;
+		}
+		return oldValue;
+	}
 #endif
 	@Override
 	public boolean containsKey(Object key) {

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

@@ -16,6 +16,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.SORTED_SET;
@@ -42,7 +43,7 @@ import speiger.src.collections.objects.sets.ObjectSet;
  * @Type(T)
  * @ValueType(V)
  */
-public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected long[] links;

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

@@ -179,6 +179,17 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 	 */
 	public void addToAll(MAP KEY_VALUE_GENERIC_TYPE m);
 	
+	/**
+	 * A Helper method to subtract from primitive from each other. If the key is not present it will just return the defaultValue
+	 * How the implementation works is that it will subtract from the current value (if not present it will do nothing) and fence it to the {@link #getDefaultReturnValue()}
+	 * If the fence is reached the element will be automaticall removed
+	 * 
+	 * @param key that should be subtract from
+	 * @param value that should be subtract
+	 * @return the last present or default return value
+	 */
+	public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value);
+	
 #endif
 	/**
 	 * Type Specific function for the bull putting of values

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

@@ -207,13 +207,13 @@ public interface NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE extends SORTED_MAP KEY_VAL
 	default NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey) { return tailMap(OBJ_TO_KEY(fromKey), true); }
 #else
 	@Override
-	default MAP.Entry KEY_VALUE_GENERIC_TYPE lowerEntry(CLASS_TYPE key) { return lowerEntry(OBJ_TO_KEY(key)); }
+	MAP.Entry KEY_VALUE_GENERIC_TYPE lowerEntry(CLASS_TYPE key);
 	@Override
-	default MAP.Entry KEY_VALUE_GENERIC_TYPE floorEntry(CLASS_TYPE key) { return floorEntry(OBJ_TO_KEY(key)); }
+	MAP.Entry KEY_VALUE_GENERIC_TYPE floorEntry(CLASS_TYPE key);
 	@Override
-	default MAP.Entry KEY_VALUE_GENERIC_TYPE ceilingEntry(CLASS_TYPE key) { return ceilingEntry(OBJ_TO_KEY(key)); }
+	MAP.Entry KEY_VALUE_GENERIC_TYPE ceilingEntry(CLASS_TYPE key);
 	@Override
-	default MAP.Entry KEY_VALUE_GENERIC_TYPE higherEntry(CLASS_TYPE key) { return higherEntry(OBJ_TO_KEY(key)); }
+	MAP.Entry KEY_VALUE_GENERIC_TYPE higherEntry(CLASS_TYPE key);
 	
 	@Override
 	public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, boolean fromInclusive, CLASS_TYPE toKey, boolean toInclusive);

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

@@ -0,0 +1,117 @@
+package speiger.src.collections.PACKAGE.maps.interfaces;
+
+import speiger.src.collections.PACKAGE.utils.maps.MAPS;
+/**
+ * A Special Map Interface giving Access to some really usefull functions
+ * The Idea behind this interface is to allow access to functions that give control to the Order of elements.
+ * Since Linked implementations as examples can be reordered outside of the Insertion Order.
+ * This interface provides basic access to such functions while also providing some Sorted/NaivgableMap implementations that still fit into here.
+ * 
+ * @Type(T)
+ * @ValueType(V)
+ */
+public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERIC_TYPE
+{
+	/**
+	 * A customized put method that allows you to insert into the first index.
+	 * @param key the key that should be inserted
+	 * @param value the value that should be inserted
+	 * @return the previous present or default return value
+	 * @see java.util.Map#put(Object, Object)
+	 */
+	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value);
+	
+	/**
+	 * A customized put method that allows you to insert into the last index. (This may be nessesary depending on the implementation)
+	 * @param key the key that should be inserted
+	 * @param value the value that should be inserted
+	 * @return the previous present or default return value
+	 * @see java.util.Map#put(Object, Object)
+	 */
+	public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value);
+	
+	/**
+	 * A specific move method to move a given key/value to the first index.
+	 * @param key that should be moved to the first index
+	 * @return true if the value was moved.
+	 * @note returns false if the value was not present in the first place
+	 */
+	public boolean moveToFirst(KEY_TYPE key);
+	/**
+	 * A specific move method to move a given key/value to the last index.
+	 * @param key that should be moved to the first last
+	 * @return true if the value was moved.
+	 * @note returns false if the value was not present in the first place
+	 */
+	public boolean moveToLast(KEY_TYPE key);
+	
+	/**
+	 * A Specific get method that allows to move teh given key/value int the first index.
+	 * @param key that is searched for
+	 * @return the given value for the requested key or default return value
+	 */
+	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key);
+	/**
+	 * A Specific get method that allows to move teh given key/value int the last index.
+	 * @param key that is searched for
+	 * @return the given value for the requested key or default return value
+	 */
+	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key);
+	
+	/**
+	 * A method to get the first Key of a Map.
+	 * @return the first key in the map
+	 */
+	public KEY_TYPE FIRST_ENTRY_KEY();
+	/**
+	 * A method to get and remove the first Key of a Map.
+	 * @return the first key in the map
+	 */
+	public KEY_TYPE POLL_FIRST_ENTRY_KEY();
+	/**
+	 * A method to get the last Key of a Map.
+	 * @return the last key in the map
+	 */
+	public KEY_TYPE LAST_ENTRY_KEY();
+	/**
+	 * A method to get and remove the last Key of a Map.
+	 * @return the last key in the map
+	 */
+	public KEY_TYPE POLL_LAST_ENTRY_KEY();
+	
+	/**
+	 * A method to get the first Value of a Map.
+	 * @return the first key in the map
+	 */
+	public VALUE_TYPE FIRST_ENTRY_VALUE();
+	/**
+	 * A method to get the last Value of a Map.
+	 * @return the last key in the map
+	 */
+	public VALUE_TYPE LAST_ENTRY_VALUE();
+	
+	@Override
+	public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy();
+	
+	/**
+	 * Creates a Wrapped SortedMap that is Synchronized
+	 * @return a new SortedMap that is synchronized
+	 * @see MAPS#synchronize
+	 */
+	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize() { return MAPS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped SortedMap that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new SortedMap Wrapper that is synchronized
+	 * @see MAPS#synchronize
+	 */
+	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize(Object mutex) { return MAPS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped SortedMap that is unmodifiable
+	 * @return a new SortedMap Wrapper that is unmodifiable
+	 * @see MAPS#unmodifiable
+	 */
+	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); }
+}

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

@@ -19,8 +19,10 @@ import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
  * 
  * @Type(T)
  * @ValueType(V)
+ * @note ORDERED_MAP is only extended until 0.6.0 for Compat reasons.
+ * The supported classes already implement ORDERED_MAP directly and will remove SORTED_MAP implementations in favor of ORDERED_MAP instead
  */
-public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
+public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE, CLASS_VALUE_TYPE>, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/**
 	 * A customized put method that allows you to insert into the first index.
@@ -29,6 +31,7 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	 * @return the previous present or default return value
 	 * @see java.util.Map#put(Object, Object)
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_MAP#putAndMoveToFirst instead (removed in 0.6.0)
 	 */
 	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value);
 	/**
@@ -38,6 +41,7 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	 * @return the previous present or default return value
 	 * @see java.util.Map#put(Object, Object)
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_MAP#putAndMoveToLast instead (removed in 0.6.0)
 	 */
 	public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value);
 	
@@ -47,6 +51,7 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	 * @return true if the value was moved.
 	 * @note returns false if the value was not present in the first place
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_MAP#moveToFirst instead (removed in 0.6.0)
 	 */
 	public boolean moveToFirst(KEY_TYPE key);
 	/**
@@ -55,6 +60,7 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	 * @return true if the value was moved.
 	 * @note returns false if the value was not present in the first place
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_MAP#moveToLast instead (removed in 0.6.0)
 	 */
 	public boolean moveToLast(KEY_TYPE key);
 	
@@ -63,6 +69,7 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	 * @param key that is searched for
 	 * @return the given value for the requested key or default return value
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_MAP#getAndMoveToFirst instead (removed in 0.6.0)
 	 */
 	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key);
 	/**
@@ -70,6 +77,7 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	 * @param key that is searched for
 	 * @return the given value for the requested key or default return value
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_MAP#getAndMoveToLast instead (removed in 0.6.0)
 	 */
 	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key);
 	

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

@@ -82,7 +82,7 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	 */
 	public ARRAY_FIFO_QUEUE(int capacity) {
 		if (capacity < 0) throw new IllegalArgumentException("Initial capacity (" + capacity + ") is negative");
-		array = NEW_KEY_ARRAY(Math.max(MIN_CAPACITY, capacity));
+		array = NEW_KEY_ARRAY(Math.max(MIN_CAPACITY, capacity+1));
 		minCapacity = array.length;
 	}
 	
@@ -114,8 +114,8 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	
 	@Override
 	public void enqueue(KEY_TYPE e) {
-		array[last] = e;
+		array[last++] = e;
-		last = ++last % array.length;
+		if(last == array.length) last = 0;
 		if(last == first) expand();
 	}
 	
@@ -133,7 +133,7 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 #if TYPE_OBJECT
 		array[first] = null;
 #endif
-		first = ++first % array.length;
+		if(++first == array.length) first = 0;
 		reduce();
 		return data;
 	}
@@ -153,7 +153,8 @@ 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();
-		return array[(first + index) % array.length];
+		index += first;
+		return index > array.length ? array[index-array.length] : array[index];
 	}
 	
 	@Override

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

@@ -19,6 +19,7 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
+import speiger.src.collections.utils.SanityChecks;
 
 /**
  * A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
@@ -70,7 +71,6 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 	public ARRAY_PRIORITY_QUEUE(int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
 		if(size < 0) throw new IllegalAccessError("Size has to be 0 or positive");
 		if(size > 0) array = NEW_KEY_ARRAY(size);
-		this.size = size;
 		comparator = comp;
 	}
 	
@@ -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, size+1);
+		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(firstIndex != -1){
 			int compare = comparator == null ? COMPAREABLE_TO_KEY(e, array[firstIndex]) : comparator.compare(e, array[firstIndex]);
 			if(compare < 0) firstIndex = size;

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

@@ -19,6 +19,7 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
+import speiger.src.collections.utils.SanityChecks;
 
 /**
  * A Simple Heap base Priority Queue implementation
@@ -66,7 +67,6 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 	 */
 	public HEAP_PRIORITY_QUEUE(int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
 		if(size > 0) array = NEW_KEY_ARRAY(size);
-		this.size = size;
 		comparator = comp;
 	}
 	
@@ -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, size + 1);
+		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));
 		array[size++] = e;
 		ARRAYS.shiftUp(array, size-1, comparator);
 	}

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

@@ -14,6 +14,11 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
  */
 public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
 {
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+	
+#endif
 	@Override
 	public abstract ITERATOR KEY_GENERIC_TYPE iterator();
 	@Override

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

@@ -36,7 +36,7 @@ import speiger.src.collections.PACKAGE.utils.ARRAYS;
  * This implementation does not shrink the backing array
  * @Type(T)
  */
-public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
+public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing Array */
 	protected transient KEY_TYPE[] data;
@@ -132,6 +132,17 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return false;
 	}
 	
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) {
+		int index = findIndex(o);
+		if(index != -1) return data[index];
+		if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
+		data[size++] = o;
+		return o;
+	}
+	
+#endif
 	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) {
 		int index = findIndex(o);
@@ -499,27 +510,30 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		throw new NoSuchElementException();
 	}
 	
+	/**
+	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
+	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
+	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
+	 * @throws UnsupportedOperationException because it is not supported
+	 */
 	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) {
+	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-		int fromIndex = findIndex(fromElement);
+	/**
-		int toIndex = findIndex(toElement);
+	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
-		if(fromIndex == -1 || toIndex == -1) throw new NoSuchElementException();
+	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
-		return new SubSet(fromIndex, toIndex - fromIndex + 1);
+	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
-	}
+	 * @throws UnsupportedOperationException because it is not supported
-
+	 */
 	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) {
+	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-		int toIndex = findIndex(toElement);
+	/**
-		if(toIndex == -1) throw new NoSuchElementException();
+	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
-		return new SubSet(0, toIndex+1);
+	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
-	}
+	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
-
+	 * @throws UnsupportedOperationException because it is not supported
+	 */
 	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) {
+	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-		int fromIndex = findIndex(fromElement);
-		if(fromIndex == -1) throw new NoSuchElementException();
-		return new SubSet(fromIndex, size - fromIndex);
-	}
 	
 	public ARRAY_SET KEY_GENERIC_TYPE copy() {
 		ARRAY_SET KEY_GENERIC_TYPE set = new ARRAY_SETBRACES();
@@ -573,345 +587,346 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return a;
 	}
 	
-	private class SubSet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+//	Disabled until a Proper Implementation can be thought out or it is decided that the interface is thrown out.
-		int offset;
+//	private class SubSet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
-		int length;
+//		int offset;
-		
+//		int length;
-		SubSet(int offset, int length) {
+//		
-			this.offset = offset;
+//		SubSet(int offset, int length) {
-			this.length = length;
+//			this.offset = offset;
-		}
+//			this.length = length;
-		
+//		}
-		int end() { return offset+length; }
+//		
-
+//		int end() { return offset+length; }
-		@Override
+//
-		public boolean add(KEY_TYPE o) {
+//		@Override
-			int index = findIndex(o);
+//		public boolean add(KEY_TYPE o) {
-			if(index == -1) {
+//			int index = findIndex(o);
-				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
+//			if(index == -1) {
-				if(end() != size) System.arraycopy(data, end(), data, end()+1, size-(offset+length));
+//				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
-				data[end()] = o;
+//				if(end() != size) System.arraycopy(data, end(), data, end()+1, size-(offset+length));
-				size++;
+//				data[end()] = o;
-				length++;
+//				size++;
-				return true;
+//				length++;
-			}
+//				return true;
-			return false;
+//			}
-		}
+//			return false;
-
+//		}
-		@Override
+//
-		public boolean addAndMoveToFirst(KEY_TYPE o) {
+//		@Override
-			int index = findIndex(o);
+//		public boolean addAndMoveToFirst(KEY_TYPE o) {
-			if(index == -1) {
+//			int index = findIndex(o);
-				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
+//			if(index == -1) {
-				System.arraycopy(data, offset, data, offset+1, size-offset);
+//				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
-				data[offset] = o;
+//				System.arraycopy(data, offset, data, offset+1, size-offset);
-				size++;
+//				data[offset] = o;
-				length++;
+//				size++;
-				return true;
+//				length++;
-			}
+//				return true;
-			else if(index != 0) {
+//			}
-				o = data[index];
+//			else if(index != 0) {
-				System.arraycopy(data, offset, data, offset+1, index-offset);
+//				o = data[index];
-				data[offset] = o;
+//				System.arraycopy(data, offset, data, offset+1, index-offset);
-			}
+//				data[offset] = o;
-			return false;
+//			}
-		}
+//			return false;
-		
+//		}
-		@Override
+//		
-		public boolean addAndMoveToLast(KEY_TYPE o) {
+//		@Override
-			int index = findIndex(o);
+//		public boolean addAndMoveToLast(KEY_TYPE o) {
-			if(index == -1) {
+//			int index = findIndex(o);
-				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
+//			if(index == -1) {
-				System.arraycopy(data, end()+1, data, end(), size-end());
+//				if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
-				data[end()] = o;
+//				System.arraycopy(data, end()+1, data, end(), size-end());
-				size++;
+//				data[end()] = o;
-				length++;
+//				size++;
-				return true;
+//				length++;
-			}
+//				return true;
-			else if(index != 0) {
+//			}
-				o = data[index];
+//			else if(index != 0) {
-				System.arraycopy(data, offset+1, data, offset, index-offset);
+//				o = data[index];
-				data[offset+length] = o;
+//				System.arraycopy(data, offset+1, data, offset, index-offset);
-			}
+//				data[offset+length] = o;
-			return false;
+//			}
-		}
+//			return false;
-		
+//		}
-		@Override
+//		
-		public boolean moveToFirst(KEY_TYPE o) {
+//		@Override
-			int index = findIndex(o);
+//		public boolean moveToFirst(KEY_TYPE o) {
-			if(index > offset) {
+//			int index = findIndex(o);
-				o = data[index];
+//			if(index > offset) {
-				System.arraycopy(data, offset, data, offset+1, index-offset);
+//				o = data[index];
-				data[offset] = o;
+//				System.arraycopy(data, offset, data, offset+1, index-offset);
-				return true;
+//				data[offset] = o;
-			}
+//				return true;
-			return false;
+//			}
-		}
+//			return false;
-		
+//		}
-		@Override
+//		
-		public boolean moveToLast(KEY_TYPE o) {
+//		@Override
-			int index = findIndex(o);
+//		public boolean moveToLast(KEY_TYPE o) {
-			if(index != -1 && index < end()-1) {
+//			int index = findIndex(o);
-				o = data[index];
+//			if(index != -1 && index < end()-1) {
-				System.arraycopy(data, index+1, data, index, end()-index-1);
+//				o = data[index];
-				data[end()-1] = o;
+//				System.arraycopy(data, index+1, data, index, end()-index-1);
-				return true;
+//				data[end()-1] = o;
-			}
+//				return true;
-			return false;
+//			}
-		}
+//			return false;
-		
+//		}
-#if !TYPE_OBJECT
+//		
-		@Override
+//#if !TYPE_OBJECT
-		public boolean contains(KEY_TYPE e) {
+//		@Override
-			return findIndex(e) != -1;
+//		public boolean contains(KEY_TYPE e) {
-		}
+//			return findIndex(e) != -1;
-		
+//		}
-#endif
+//		
-		@Override
+//#endif
-		public boolean contains(Object e) {
+//		@Override
-			return findIndex(e) != -1;
+//		public boolean contains(Object e) {
-		}
+//			return findIndex(e) != -1;
-		
+//		}
-		@Override
+//		
-		public KEY_TYPE FIRST_KEY() {
+//		@Override
-			if(length == 0) throw new NoSuchElementException();
+//		public KEY_TYPE FIRST_KEY() {
-			return data[offset];
+//			if(length == 0) throw new NoSuchElementException();
-		}
+//			return data[offset];
-		
+//		}
-		@Override
+//		
-		public KEY_TYPE LAST_KEY() {
+//		@Override
-			if(length == 0) throw new NoSuchElementException();
+//		public KEY_TYPE LAST_KEY() {
-			return data[end()-1];
+//			if(length == 0) throw new NoSuchElementException();
-		}
+//			return data[end()-1];
-		
+//		}
-#if !TYPE_OBJECT
+//		
-		@Override
+//#if !TYPE_OBJECT
-		public boolean remove(KEY_TYPE o) {
+//		@Override
-			int index = findIndex(o);
+//		public boolean remove(KEY_TYPE o) {
-			if(index != -1) {
+//			int index = findIndex(o);
-				size--;
+//			if(index != -1) {
-				length--;
+//				size--;
-				if(index != size) System.arraycopy(data, index+1, data, index, size - index);
+//				length--;
-				return true;
+//				if(index != size) System.arraycopy(data, index+1, data, index, size - index);
-			}
+//				return true;
-			return false;
+//			}
-		}
+//			return false;
-		
+//		}
-#endif
+//		
-		@Override
+//#endif
-		public boolean remove(Object o) {
+//		@Override
-			int index = findIndex(o);
+//		public boolean remove(Object o) {
-			if(index != -1) {
+//			int index = findIndex(o);
-				size--;
+//			if(index != -1) {
-				length--;
+//				size--;
-				if(index != size) System.arraycopy(data, index+1, data, index, size - index);
+//				length--;
-#if TYPE_OBJECT
+//				if(index != size) System.arraycopy(data, index+1, data, index, size - index);
-				data[size] = EMPTY_KEY_VALUE;
+//#if TYPE_OBJECT
-#endif
+//				data[size] = EMPTY_KEY_VALUE;
-				return true;
+//#endif
-			}
+//				return true;
-			return false;
+//			}
-		}
+//			return false;
-		
+//		}
-		@Override
+//		
-		public KEY_TYPE POLL_FIRST_KEY() {
+//		@Override
-			if(length == 0) throw new NoSuchElementException();
+//		public KEY_TYPE POLL_FIRST_KEY() {
-			size--;
+//			if(length == 0) throw new NoSuchElementException();
-			length--;
+//			size--;
-			KEY_TYPE result = data[offset];
+//			length--;
-			System.arraycopy(data, offset+1, data, offset, size-offset);
+//			KEY_TYPE result = data[offset];
-#if TYPE_OBJECT
+//			System.arraycopy(data, offset+1, data, offset, size-offset);
-			data[size] = EMPTY_KEY_VALUE;
+//#if TYPE_OBJECT
-#endif
+//			data[size] = EMPTY_KEY_VALUE;
-			return result;
+//#endif
-		}
+//			return result;
-		
+//		}
-		@Override
+//		
-		public KEY_TYPE POLL_LAST_KEY() {
+//		@Override
-			if(length == 0) throw new NoSuchElementException();
+//		public KEY_TYPE POLL_LAST_KEY() {
-			KEY_TYPE result = data[offset+length];
+//			if(length == 0) throw new NoSuchElementException();
-			size--;
+//			KEY_TYPE result = data[offset+length];
-			length--;
+//			size--;
-			System.arraycopy(data, end()+1, data, end(), size-end());
+//			length--;
-#if TYPE_OBJECT
+//			System.arraycopy(data, end()+1, data, end(), size-end());
-			data[size] = EMPTY_KEY_VALUE;
+//#if TYPE_OBJECT
-#endif
+//			data[size] = EMPTY_KEY_VALUE;
-			return result;
+//#endif
-		}
+//			return result;
-		
+//		}
-		@Override
+//		
-		public COMPARATOR KEY_GENERIC_TYPE comparator() {
+//		@Override
-			return null;
+//		public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		}
+//			return null;
-
+//		}
-		@Override
+//
-		public BI_ITERATOR KEY_GENERIC_TYPE iterator() {
+//		@Override
-			return new SetIterator(offset);
+//		public BI_ITERATOR KEY_GENERIC_TYPE iterator() {
-		}
+//			return new SetIterator(offset);
-
+//		}
-		@Override
+//
-		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
+//		@Override
-			int index = findIndex(fromElement);
+//		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
-			if(index != -1) return new SetIterator(index);
+//			int index = findIndex(fromElement);
-			throw new NoSuchElementException();
+//			if(index != -1) return new SetIterator(index);
-		}
+//			throw new NoSuchElementException();
-		
+//		}
-		@Override
+//		
-		public SubSet copy() { throw new UnsupportedOperationException(); }
+//		@Override
-		
+//		public SubSet copy() { throw new UnsupportedOperationException(); }
-		@Override
+//		
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) {
+//		@Override
-			int fromIndex = findIndex(fromElement);
+//		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) {
-			int toIndex = findIndex(toElement);
+//			int fromIndex = findIndex(fromElement);
-			if(fromIndex == -1 || toIndex == -1) throw new NoSuchElementException();
+//			int toIndex = findIndex(toElement);
-			return new SubSet(fromIndex, toIndex - fromIndex + 1);
+//			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) {
+//		@Override
-			int toIndex = findIndex(toElement);
+//		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) {
-			if(toIndex == -1) throw new NoSuchElementException();
+//			int toIndex = findIndex(toElement);
-			return new SubSet(0, toIndex+1);
+//			if(toIndex == -1) throw new NoSuchElementException();
-		}
+//			return new SubSet(0, toIndex+1);
-
+//		}
-		@Override
+//
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) {
+//		@Override
-			int fromIndex = findIndex(fromElement);
+//		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) {
-			if(fromIndex == -1) throw new NoSuchElementException();
+//			int fromIndex = findIndex(fromElement);
-			return new SubSet(fromIndex, size - fromIndex);
+//			if(fromIndex == -1) throw new NoSuchElementException();
-		}
+//			return new SubSet(fromIndex, size - fromIndex);
-		
+//		}
-		@Override
+//		
-		public int size() {
+//		@Override
-			return length;
+//		public int size() {
-		}
+//			return length;
-		
+//		}
-#if !TYPE_OBJECT
+//		
-		@Override
+//#if !TYPE_OBJECT
-		public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
+//		@Override
-			if(a == null || a.length < size()) return Arrays.copyOfRange(data, offset, end());
+//		public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
-			System.arraycopy(data, offset, a, 0, size());
+//			if(a == null || a.length < size()) return Arrays.copyOfRange(data, offset, end());
-			return a;
+//			System.arraycopy(data, offset, a, 0, size());
-		}
+//			return a;
-		
+//		}
-#endif
+//		
-		@Override
+//#endif
-		@Deprecated
+//		@Override
-		public Object[] toArray() {
+//		@Deprecated
-			Object[] obj = new Object[size()];
+//		public Object[] toArray() {
-			for(int i = 0;i<size();i++)
+//			Object[] obj = new Object[size()];
-				obj[i] = KEY_TO_OBJ(data[offset+i]);
+//			for(int i = 0;i<size();i++)
-			return obj;
+//				obj[i] = KEY_TO_OBJ(data[offset+i]);
-		}
+//			return obj;
-		
+//		}
-		@Override
+//		
-		@Primitive
+//		@Override
-		public <E> E[] toArray(E[] a) {
+//		@Primitive
-			if(a == null) a = (E[])new Object[size()];
+//		public <E> E[] toArray(E[] a) {
-			else if(a.length < size()) a = (E[])ObjectArrays.newArray(a.getClass().getComponentType(), size());
+//			if(a == null) a = (E[])new Object[size()];
-			for(int i = 0;i<size();i++)
+//			else if(a.length < size()) a = (E[])ObjectArrays.newArray(a.getClass().getComponentType(), size());
-				a[i] = (E)KEY_TO_OBJ(data[offset+i]);
+//			for(int i = 0;i<size();i++)
-			return a;
+//				a[i] = (E)KEY_TO_OBJ(data[offset+i]);
-		}
+//			return a;
-		
+//		}
-#if !TYPE_OBJECT
+//		
-		protected int findIndex(KEY_TYPE o) {
+//#if !TYPE_OBJECT
-			for(int i = length-1;i>=0;i--)
+//		protected int findIndex(KEY_TYPE o) {
-				if(KEY_EQUALS(data[offset+i], o)) return i + offset;
+//			for(int i = length-1;i>=0;i--)
-			return -1;
+//				if(KEY_EQUALS(data[offset+i], o)) return i + offset;
-		}
+//			return -1;
-		
+//		}
-#endif
+//		
-		protected int findIndex(Object o) {
+//#endif
-			for(int i = length-1;i>=0;i--)
+//		protected int findIndex(Object o) {
-				if(EQUALS_KEY_TYPE(data[offset+i], o)) return i + offset;
+//			for(int i = length-1;i>=0;i--)
-			return -1;
+//				if(EQUALS_KEY_TYPE(data[offset+i], o)) return i + offset;
-		}
+//			return -1;
-		
+//		}
-		private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
+//		
-			int index;
+//		private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
-			int lastReturned = -1;
+//			int index;
-			
+//			int lastReturned = -1;
-			public SetIterator(int index) {
+//			
-				this.index = index;
+//			public SetIterator(int index) {
-			}
+//				this.index = index;
-			
+//			}
-			@Override
+//			
-			public boolean hasNext() {
+//			@Override
-				return index < size();
+//			public boolean hasNext() {
-			}
+//				return index < size();
-			
+//			}
-			@Override
+//			
-			public KEY_TYPE NEXT() {
+//			@Override
-				if(!hasNext()) throw new NoSuchElementException();
+//			public KEY_TYPE NEXT() {
-				lastReturned = index;
+//				if(!hasNext()) throw new NoSuchElementException();
-				return data[index++];
+//				lastReturned = index;
-			}
+//				return data[index++];
-			
+//			}
-			@Override
+//			
-			public boolean hasPrevious() {
+//			@Override
-				return index > 0;
+//			public boolean hasPrevious() {
-			}
+//				return index > 0;
-			
+//			}
-			@Override
+//			
-			public KEY_TYPE PREVIOUS() {
+//			@Override
-				if(!hasPrevious()) throw new NoSuchElementException();
+//			public KEY_TYPE PREVIOUS() {
-				lastReturned = index;
+//				if(!hasPrevious()) throw new NoSuchElementException();
-				return data[index--];
+//				lastReturned = index;
-			}
+//				return data[index--];
-			
+//			}
-			@Override
+//			
-			public int nextIndex() {
+//			@Override
-				return index;
+//			public int nextIndex() {
-			}
+//				return index;
-			
+//			}
-			@Override
+//			
-			public int previousIndex() {
+//			@Override
-				return index-1;
+//			public int previousIndex() {
-			}
+//				return index-1;
-			
+//			}
-			@Override
+//			
-			public void remove() {
+//			@Override
-				if(lastReturned == -1)
+//			public void remove() {
-					throw new IllegalStateException();
+//				if(lastReturned == -1)
-				SubSet.this.remove(data[lastReturned]);
+//					throw new IllegalStateException();
-				if(lastReturned < index)
+//				SubSet.this.remove(data[lastReturned]);
-					index--;
+//				if(lastReturned < index)
-				lastReturned = -1;
+//					index--;
-			}
+//				lastReturned = -1;
-			
+//			}
-		#if TYPE_OBJECT
+//			
-			@Override
+//		#if TYPE_OBJECT
-			public void set(Object e) { throw new UnsupportedOperationException(); }
+//			@Override
-			
+//			public void set(Object e) { throw new UnsupportedOperationException(); }
-			@Override
+//			
-			public void add(Object e) { throw new UnsupportedOperationException(); }
+//			@Override
-			
+//			public void add(Object e) { throw new UnsupportedOperationException(); }
-		#else
+//			
-			@Override
+//		#else
-			public void set(KEY_TYPE e) { throw new UnsupportedOperationException(); }
+//			@Override
-		
+//			public void set(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-			@Override
+//		
-			public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
+//			@Override
-			
+//			public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-		#endif
+//			
-			@Override
+//		#endif
-			public int skip(int amount) {
+//			@Override
-				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
+//			public int skip(int amount) {
-				int steps = Math.min(amount, (size() - 1) - index);
+//				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-				index += steps;
+//				int steps = Math.min(amount, (size() - 1) - index);
-				return steps;
+//				index += steps;
-			}
+//				return steps;
-			
+//			}
-			@Override
+//			
-			public int back(int amount) {
+//			@Override
-				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
+//			public int back(int amount) {
-				int steps = Math.min(amount, index);
+//				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-				index -= steps;
+//				int steps = Math.min(amount, index);
-				return steps;
+//				index -= steps;
-			}
+//				return steps;
-		}
+//			}
-	}
+//		}
+//	}
 	
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		int index;

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

@@ -241,6 +241,10 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	
 	@Override
 	public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#endif
 	@Override
 	@Primitive
 	public boolean addAll(Collection<? extends CLASS_TYPE> c) { throw new UnsupportedOperationException(); }
@@ -257,7 +261,12 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	
 	@Override
 	public boolean contains(Object o) {
+#if TYPE_OBJECT
 		if(o == null) return containsNull;
+#else
+		if(o == null) return false;
+		if(o instanceof CLASS_TYPE && KEY_EQUALS(CLASS_TO_KEY(o), EMPTY_KEY_VALUE)) return containsNull;
+#endif
 		int pos = HashUtil.mix(o.hashCode()) & mask;
 		KEY_TYPE current = keys[pos];
 		if(KEY_EQUALS_NULL(current)) return false;

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

@@ -37,7 +37,7 @@ import speiger.src.collections.utils.SanityChecks;
  * This implementation of SortedSet does not support SubSet of any kind. It implements the interface due to sortability and first/last access
  * @Type(T)
  */
-public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
+public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;

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

@@ -38,7 +38,7 @@ import speiger.src.collections.utils.SanityChecks;
  * This implementation of SortedSet does not support SubSet of any kind. It implements the interface due to sortability and first/last access
  * @Type(T)
  */
-public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
+public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;

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

@@ -171,10 +171,10 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet<CLASS_TYPE>
 	default CLASS_TYPE last() { return SORTED_SET.super.last(); }
 	@Override
 	@Deprecated
-	public default CLASS_TYPE pollFirst() { return KEY_TO_OBJ(POLL_FIRST_KEY()); }
+	public default CLASS_TYPE pollFirst() { return isEmpty() ? null : KEY_TO_OBJ(POLL_FIRST_KEY()); }
 	@Override
 	@Deprecated
-	public default CLASS_TYPE pollLast() { return KEY_TO_OBJ(POLL_LAST_KEY()); }
+	public default CLASS_TYPE pollLast() { return isEmpty() ? null : KEY_TO_OBJ(POLL_LAST_KEY()); }
 	
 	@Override
 	@Deprecated

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

@@ -277,6 +277,30 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 		return true;
 	}
 	
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) {
+		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
+			if(containsNull) return EMPTY_KEY_VALUE;
+			containsNull = true;
+			onNodeAdded(nullIndex);
+		}
+		else {
+			int pos = HashUtil.mix(strategy.hashCode(o)) & mask;
+			KEY_TYPE current = keys[pos];
+			if(!strategy.equals(current, EMPTY_KEY_VALUE)) {
+				if(strategy.equals(current, o)) return current;
+				while(!strategy.equals((current = keys[pos = (++pos & mask)]), EMPTY_KEY_VALUE))
+					if(strategy.equals(current, o)) return current;
+			}
+			keys[pos] = o;
+			onNodeAdded(pos);
+		}
+		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
+		return o;
+	}
+	
+#endif
 	@Override
 	@Primitive
 	public boolean addAll(Collection<? extends CLASS_TYPE> c) {

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

@@ -235,6 +235,30 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 		return true;
 	}
 	
+#if TYPE_OBJECT
+	@Override
+	public KEY_TYPE addOrGet(KEY_TYPE o) {
+		if(KEY_EQUALS_NULL(o)) {
+			if(containsNull) return null;
+			containsNull = true;
+			onNodeAdded(nullIndex);
+		}
+		else {
+			int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask;
+			KEY_TYPE current = keys[pos];
+			if(KEY_EQUALS_NOT_NULL(current)) {
+				if(KEY_EQUALS(current, o)) return current;
+				while(KEY_EQUALS_NOT_NULL((current = keys[pos = (++pos & mask)])))
+					if(KEY_EQUALS(current, o)) return current;
+			}
+			keys[pos] = o;
+			onNodeAdded(pos);
+		}
+		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
+		return o;
+	}
+	
+#endif
 	@Override
 	@Primitive
 	public boolean addAll(Collection<? extends CLASS_TYPE> c) {
@@ -252,7 +276,12 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 	
 	@Override
 	public boolean contains(Object o) {
+#if TYPE_OBJECT
 		if(o == null) return containsNull;
+#else
+		if(o == null) return false;
+		if(o instanceof CLASS_TYPE && KEY_EQUALS(CLASS_TO_KEY(o), EMPTY_KEY_VALUE)) return containsNull;
+#endif
 		int pos = HashUtil.mix(o.hashCode()) & mask;
 		KEY_TYPE current = keys[pos];
 		if(KEY_EQUALS_NULL(current)) return false;
@@ -265,7 +294,12 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 
 	@Override
 	public boolean remove(Object o) {
+#if TYPE_OBJECT
 		if(o == null) return (containsNull ? removeNullIndex() : false);
+#else
+		if(o == null) return false;
+		if(o instanceof CLASS_TYPE && KEY_EQUALS(CLASS_TO_KEY(o), EMPTY_KEY_VALUE)) return (containsNull ? removeNullIndex() : false);
+#endif
 		int pos = HashUtil.mix(o.hashCode()) & mask;
 		KEY_TYPE current = keys[pos];
 		if(KEY_EQUALS_NULL(current)) return false;

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

@@ -0,0 +1,114 @@
+package speiger.src.collections.PACKAGE.sets;
+
+import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
+import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
+import speiger.src.collections.PACKAGE.utils.SETS;
+import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
+
+/**
+ * A Special Set Interface giving Access to some really usefull functions
+ * The Idea behind this interface is to allow access to functions that give control to the Order of elements.
+ * Since Linked implementations as examples can be reordered outside of the Insertion Order.
+ * This interface provides basic access to such functions while also providing some Sorted/NaivgableSet implementations that still fit into here.
+ * 
+ * @Type(T)
+ */
+public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE
+{
+	/**
+	 * A customized add method that allows you to insert into the first index.
+	 * @param o the element that should be inserted
+	 * @return true if it was added
+	 * @see java.util.Set#add(Object)
+	 */
+	public boolean addAndMoveToFirst(KEY_TYPE o);
+	/**
+	 * A customized add method that allows you to insert into the last index.
+	 * @param o the element that should be inserted
+	 * @return true if it was added
+	 * @see java.util.Set#add(Object)
+	 */
+	public boolean addAndMoveToLast(KEY_TYPE o);
+	
+	/**
+	 * A specific move method to move a given key to the first index.
+	 * @param o that should be moved to the first index
+	 * @return true if the value was moved.
+	 * @note returns false if the value was not present in the first place
+	 */
+	public boolean moveToFirst(KEY_TYPE o);
+	/**
+	 * A specific move method to move a given key to the last index.
+	 * @param o that should be moved to the first last
+	 * @return true if the value was moved.
+	 * @note returns false if the value was not present in the first place
+	 */
+	public boolean moveToLast(KEY_TYPE o);
+	
+	@Override
+	public ORDERED_SET KEY_GENERIC_TYPE copy();
+	
+	@Override
+	public BI_ITERATOR KEY_GENERIC_TYPE iterator();
+	
+	/**
+	 * A type Specific Iterator starting from a given key
+	 * @param fromElement the element the iterator should start from
+	 * @return a iterator starting from the given element
+	 * @throws java.util.NoSuchElementException if fromElement isn't found
+	 */
+	public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement);
+	
+	/**
+	 * A Type Specific Type Splititerator to reduce boxing/unboxing
+	 * @return type specific splititerator
+	 */
+	@Override
+	default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
+	
+	/**
+	 * A method to get the first element in the set
+	 * @return first element in the set
+	 */
+	public KEY_TYPE FIRST_KEY();
+	/**
+	 * A method to get and remove the first element in the set
+	 * @return first element in the set
+	 */
+	public KEY_TYPE POLL_FIRST_KEY();
+	/**
+	 * A method to get the last element in the set
+	 * @return last element in the set
+	 */
+	public KEY_TYPE LAST_KEY();
+	/**
+	 * A method to get and remove the last element in the set
+	 * @return last element in the set
+	 */
+	public KEY_TYPE POLL_LAST_KEY();
+	
+#if !TYPE_BOOLEAN
+	/**
+	 * Creates a Wrapped OrderedSet that is Synchronized
+	 * @return a new OrderedSet that is synchronized
+	 * @see SETS#synchronize
+	 */
+	public default ORDERED_SET KEY_GENERIC_TYPE synchronize() { return SETS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped OrderedSet that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new OrderedSet Wrapper that is synchronized
+	 * @see SETS#synchronize
+	 */
+	public default ORDERED_SET KEY_GENERIC_TYPE synchronize(Object mutex) { return SETS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped OrderedSet that is unmodifiable
+	 * @return a new OrderedSet Wrapper that is unmodifiable
+	 * @see SETS#unmodifiable
+	 */
+	public default ORDERED_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); }
+	
+#endif
+}

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

@@ -54,6 +54,15 @@ public interface SET KEY_GENERIC_TYPE extends Set<CLASS_TYPE>, COLLECTION KEY_GE
 		return COLLECTION.super.remove(o);
 	}
 	
+#else
+	/**
+	 * A Helper method that allows to add a element or getting the already present implement.
+	 * Allowing to make unique references reuseable.
+	 * @param o the element to add
+	 * @return either the inserted element or the present element.
+	 */
+	public KEY_TYPE addOrGet(KEY_TYPE o);
+	
 #endif
 #if !TYPE_BOOLEAN
 	/**

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

@@ -16,8 +16,10 @@ import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
  * A Type Specific SortedSet implementation to reduce boxing/unboxing
  * with a couple extra methods that allow greater control over sets.
  * @Type(T)
+ * @note ORDERED_SET is only extended until 0.6.0 for Compat reasons.
+ * The supported classes already implement ORDERED_SET directly and will remove SORTED_SET implementations in favor of ORDERED_SET instead
  */
-public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, SortedSet<CLASS_TYPE>
+public interface SORTED_SET KEY_GENERIC_TYPE extends ORDERED_SET KEY_GENERIC_TYPE, SortedSet<CLASS_TYPE>
 {
 	
 	/**
@@ -26,6 +28,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte
 	 * @return true if it was added
 	 * @see java.util.Set#add(Object)
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_SET#addAndMoveToFirst instead (removed in 0.6.0)
 	 */
 	public boolean addAndMoveToFirst(KEY_TYPE o);
 	/**
@@ -34,6 +37,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte
 	 * @return true if it was added
 	 * @see java.util.Set#add(Object)
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_SET#addAndMoveToLast instead (removed in 0.6.0)
 	 */
 	public boolean addAndMoveToLast(KEY_TYPE o);
 	
@@ -43,6 +47,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte
 	 * @return true if the value was moved.
 	 * @note returns false if the value was not present in the first place
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_SET#moveToFirst instead (removed in 0.6.0)
 	 */
 	public boolean moveToFirst(KEY_TYPE o);
 	/**
@@ -51,6 +56,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte
 	 * @return true if the value was moved.
 	 * @note returns false if the value was not present in the first place
 	 * @note some implementations do not support this method
+	 * @deprecated use ORDERED_SET#moveToLast instead (removed in 0.6.0)
 	 */
 	public boolean moveToLast(KEY_TYPE o);
 	

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

@@ -0,0 +1,882 @@
+package speiger.src.collections.PACKAGE.utils;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.locks.LockSupport;
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+#if !TYPE_OBJECT
+
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
+#else
+import java.util.function.BiFunction;
+
+#endif
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.functions.TASK;
+import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+#if !TYPE_BOOLEAN
+import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
+#endif
+#if !TYPE_BOOLEAN
+import speiger.src.collections.booleans.utils.BooleanAsyncBuilder;
+import speiger.src.collections.booleans.utils.BooleanAsyncBuilder.BaseBooleanTask;
+#endif
+#if !TYPE_OBJECT
+import speiger.src.collections.objects.utils.ObjectAsyncBuilder;
+import speiger.src.collections.objects.utils.ObjectAsyncBuilder.BaseObjectTask;
+#endif
+#if !TYPE_INT
+import speiger.src.collections.ints.utils.IntAsyncBuilder;
+import speiger.src.collections.ints.utils.IntAsyncBuilder.BaseIntTask;
+#endif
+import speiger.src.collections.utils.SanityChecks;
+
+/**
+ * 
+ * 
+ * The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity. <br> 
+ * It uses the Lightweight Stream Replace API to do its work, which can make it faster then sequential streams. <br>
+ * This feature isn't designed to do Multithreading work, but to allow moving work off the main thread into a worker thread. <br>
+ * So anything executed on this is still Singlethreaded. <br>
+ * <br>
+ * How it works is you create the AsyncBuilder using a Iterable of the Type. <br>
+ * Then select things you want to use on the Iterable. <br>
+ * - For example: map/filter/peek/limit/etc <br>
+ * <br>
+ * After that you select your action the Iterable should be applied on. <br>
+ * - For Example: forEach/findFirst/matchAny/etc <br>
+ * <br>
+ * Then optionally a custom Executor or callback can be applied <br>
+ * At the end either execute or join can be called to start the task. <br>
+ * - execute will return the Task reference so that the task can be traced back. <br>
+ * - join will await the completion of the task and return the return value <br>
+ * <br>
+ * During Construction a couple Disposable Builder Objects will be created. <br>
+ * These will be only used during construction. <br>
+ * <br>
+ * The Task Object is also pause-able/Interruptable at any moment during the Processing. <br>
+ * 
+ * A small example
+ * <pre>
+ * 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 (Optional)
+ * 		.execute() //Starts the task. (Required)
+ * }
+ * </pre>
+ * @author Speiger
+ * 
+ * @Type(T)
+ */
+public class ASYNC_BUILDER KEY_GENERIC_TYPE
+{
+	ITERABLE KEY_GENERIC_TYPE iterable;
+	BASE_TASK KEY_GENERIC_TYPE task;
+	
+	/**
+	 * Main Constructor that uses a Iterable to build a Offthread Task.
+	 * @param iterable
+	 */
+	public ASYNC_BUILDER(ITERABLE KEY_GENERIC_TYPE iterable) {
+		this.iterable = iterable;
+	}
+	
+	/**
+	 * Helper constructor.
+	 * @param task
+	 */
+	public ASYNC_BUILDER(BASE_TASK KEY_GENERIC_TYPE task) {
+		this.task = task;
+	}
+	
+	/**
+	 * Maps the elements to something else
+	 * @param mapper the mapping function
+	 * @param <E> The return type.
+	 * @return a new Builder Object with the mapped Iterable
+	 */
+	public <E> ObjectAsyncBuilder<E> map(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E> mapper) {
+		return new ObjectAsyncBuilder<>(ITERABLES.map(iterable, mapper));
+	}
+	
+	/**
+	 * Maps the elements to something else
+	 * @param mapper the flatMapping function
+	 * @param <V> The return type supplier.
+	 * @param <E> The return type.
+	 * @return a new Builder Object with the mapped Iterable
+	 */
+	public <E, V extends Iterable<E>> ObjectAsyncBuilder<E> flatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<V> mapper) {
+		return new ObjectAsyncBuilder<>(ITERABLES.flatMap(iterable, mapper));
+	}
+	
+	/**
+	 * Maps the elements to something else
+	 * @param mapper the flatMapping function
+	 * @param <E> The return type.
+	 * @return a new Builder Object with the mapped Iterable
+	 */
+	public <E> ObjectAsyncBuilder<E> arrayflatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E[]> mapper) {
+		return new ObjectAsyncBuilder<>(ITERABLES.arrayFlatMap(iterable, mapper));
+	}
+	
+	/**
+	 * Filters out the unwanted elements out of the Iterable
+	 * @param filter the elements that should be kept
+	 * @return Self with a filter applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE filter(PREDICATE KEY_GENERIC_TYPE filter) {
+		iterable = ITERABLES.filter(iterable, filter);
+		return this;
+	}
+	
+	/**
+	 * Removes duplicated elements out of the Iterable
+	 * @return Self with a deduplicator applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE distinct() {
+		iterable = ITERABLES.distinct(iterable);
+		return this;
+	}
+	
+	/**
+	 * Limits how many elements are inside of the Iterable
+	 * @param limit how many elements should max be iterated through
+	 * @return self with a limiter applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE limit(long limit) {
+		iterable = ITERABLES.limit(iterable, limit);
+		return this;
+	}
+	
+	/**
+	 * Allows to preview elements before they are processed
+	 * @param action the action that should be applied
+	 * @return self with a preview applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE peek(CONSUMER KEY_GENERIC_TYPE action) {
+		iterable = ITERABLES.peek(iterable, action);
+		return this;
+	}
+	
+	/**
+	 * Iterates over the Iterable with a desired action
+	 * @param action that should be applied
+	 * @return a new Builder with the forEach action applied.
+	 */
+	public ObjectAsyncBuilder<Void> forEach(CONSUMER KEY_GENERIC_TYPE action) {
+		return new ObjectAsyncBuilder<>(new ForEachTask<>(iterable.iterator(), action));
+	}
+	
+	/**
+	 * Reduces the elements inside of the Iterable down to one element
+	 * @param operator that reduces the elements.
+	 * @return self with the reduce action applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		task = new SimpleReduceTaskBRACES(iterable.iterator(), operator);
+		return this;
+	}
+	
+#if TYPE_OBJECT
+	/**
+	 * Reduces the elements inside of the Iterable down to one element using a identity element.
+	 * @param <E> the return type
+	 * @param identity the element the reduce function should start with
+	 * @param operator that reduces the elements.
+	 * @return a new Builder with the reduce function applied
+	 */
+	public <KEY_SPECIAL_TYPE> ASYNC_BUILDER<KEY_SPECIAL_TYPE> reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		return new ASYNC_BUILDERBRACES(new ReduceTaskBRACES(iterable.iterator(), operator, identity));
+	}
+	
+#else
+	/**
+	 * Reduces the elements inside of the Iterable down to one element using a identity element.
+	 * @param identity the element the reduce function should start with
+	 * @param operator that reduces the elements.
+	 * @return a new Builder with the reduce function applied
+	 */
+	public ASYNC_BUILDER reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		return new ASYNC_BUILDERBRACES(new ReduceTaskBRACES(iterable.iterator(), operator, identity));
+	}
+	
+#endif
+	/**
+	 * Pours all elements into a List that can be later
+	 * @return a new Builder with the pour function applied
+	 */
+	public ObjectAsyncBuilder<LIST KEY_GENERIC_TYPE> pourAsList() {
+		return pour(new ARRAY_LISTBRACES());
+	}
+	
+#if !TYPE_BOOLEAN
+	/**
+	 * Pours all elements into a Set that can be later
+	 * @return a new Builder with the pour function applied
+	 */
+	public ObjectAsyncBuilder<SET KEY_GENERIC_TYPE> pourAsSet() {
+		return pour(new LINKED_HASH_SETBRACES());
+	}
+	
+#endif
+	/**
+	 * Pours all elements into a collection that can be later
+	 * @param <E> the return type
+	 * @param collection the collection the elements
+	 * @return a new Builder with the pour function applied
+	 */
+	public <E extends COLLECTION KEY_GENERIC_TYPE> ObjectAsyncBuilder<E> pour(E collection) {
+		return new ObjectAsyncBuilder<>(new CollectTask<>(iterable.iterator(), collection));
+	}
+	
+	/**
+	 * Searches through the elements of the Iterable to find if the desired element is present.
+	 * @param filter that decides the desired elements
+	 * @return a new Builder with the matchAny function applied
+	 */
+	public BooleanAsyncBuilder matchAny(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new BooleanAsyncBuilder(new MatchTaskBRACES(iterable.iterator(), filter, 0));
+	}
+	
+	/**
+	 * Searches through the elements of the Iterable to find if unwanted elements are present.
+	 * @param filter that decides the unwanted elements
+	 * @return a new Builder with the matchNone function applied
+	 */
+	public BooleanAsyncBuilder matchNone(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new BooleanAsyncBuilder(new MatchTaskBRACES(iterable.iterator(), filter, 1));
+	}
+	
+	/**
+	 * Searches through the elements of the Iterable to find if all the desired elements are present.
+	 * @param filter that decides the desired elements
+	 * @return a new Builder with the matchAll function applied
+	 */
+	public BooleanAsyncBuilder matchAll(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new BooleanAsyncBuilder(new MatchTaskBRACES(iterable.iterator(), filter, 2));
+	}
+	
+	/**
+	 * Searches through the elements of the Iterable to find if the desired element.
+	 * If not present it will return the default value of the type
+	 * @param filter that decides the desired elements
+	 * @return self with the findFirst function applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		task = new FindFirstTaskBRACES(iterable.iterator(), filter);
+		return this;
+	}
+	
+	/**
+	 * Counts all desired elements inside the Iterable
+	 * @param filter that decides the desired elements
+	 * @return a new Builder with the count function applied
+	 */
+	public IntAsyncBuilder count(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new IntAsyncBuilder(new CountTaskBRACES(iterable.iterator(), filter));
+	}
+	
+	/**
+	 * Optional way to add a custom executor that runs this offthread task.
+	 * Can only be set after the action was decided on.
+	 * @param executor that executes the task, defaults to {@link SanityChecks#invokeAsyncTask(Runnable) }
+	 * @return self with the executor set
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE executor(@Nonnull Executor executor) {
+		if(task == null) throw new IllegalStateException("Action is missing");
+		task.withExecutor(executor);
+		return this;
+	}
+	
+	/**
+	 * Optional way to set a callback that allows to compute actions after the task was completed.
+	 * The state of the task has to be validated by the callback.
+	 * @param callback that should be notified after completion of the task
+	 * @return self with the callback set
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE callback(@Nullable Consumer<TASK KEY_GENERIC_TYPE> callback) {
+		if(task == null) throw new IllegalStateException("Action is missing");
+		task.withCallback(callback);
+		return this;
+	}
+	
+	/**
+	 * Starts the Execution of the task without awaiting its result
+	 * @return the task object that allow to trace it.
+	 */
+	public TASK KEY_GENERIC_TYPE execute() {
+		BASE_TASK KEY_GENERIC_TYPE toRun = task;
+		toRun.begin();
+		task = null;
+		return toRun;
+	}
+	
+	/**
+	 * Starts the Execution of the task and will await its completion, returning the result.
+	 * @return the result of the task provided.
+	 * @throws ExecutionException if the task threw a exception
+	 * @throws InterruptedException if the caller thread was interrupted
+	 */
+	public KEY_TYPE join() throws ExecutionException, InterruptedException {
+		BASE_TASK KEY_GENERIC_TYPE toRun = task;
+		task = null;
+		toRun.begin();
+		return toRun.GET_KEY();
+	}
+	
+	/**
+	 * Starts the Execution of the task and will await its completion with a timeout, returning the result.
+	 * @param timeout of how long the thread should wait the task to be completed
+	 * @param unit of the desired waiting time.
+	 * @return the result of the provided task
+	 * @throws InterruptedException if the caller thread was interrupted
+	 * @throws ExecutionException if the task threw a exception
+	 * @throws TimeoutException if the timeout was reached before the task was finished
+	 */
+	public KEY_TYPE join(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+		BASE_TASK KEY_GENERIC_TYPE toRun = task;
+		task = null;
+		toRun.begin();
+		return toRun.GET_KEY(timeout, unit);
+	}
+	
+#if !TYPE_OBJECT
+	private static class ReduceTask extends BASE_TASK
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator;
+		KEY_TYPE value;
+		
+		public ReduceTask(ITERATOR KEY_GENERIC_TYPE iter, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator, KEY_TYPE value) {
+			this.iter = iter;
+			this.operator = operator;
+			this.value = value;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				value = operator.apply(value, iter.NEXT());
+			}
+			if(!iter.hasNext()) {
+				setResult(value);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			operator = null;
+#if TYPE_OBJECT
+			value = null;
+#endif
+		}
+	}
+	
+#else
+	private static class ReduceTask<T, E> extends BaseObjectTask<E>
+	{
+		ObjectIterator<T> iter;
+		BiFunction<E, T, E> operator;
+		E value;
+		
+		public ReduceTask(ITERATOR KEY_GENERIC_TYPE iter, BiFunction<E, T, E> operator, E value) {
+			this.iter = iter;
+			this.operator = operator;
+			this.value = value;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				value = operator.apply(value, iter.NEXT());
+			}
+			if(!iter.hasNext()) {
+				setResult(value);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			operator = null;
+#if TYPE_OBJECT
+			value = null;
+#endif
+		}
+	}
+	
+#endif
+	private static class SimpleReduceTask KEY_GENERIC_TYPE extends BASE_TASK KEY_GENERIC_TYPE
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator;
+		boolean first = true;
+		KEY_TYPE value;
+		
+		public SimpleReduceTask(ITERATOR KEY_GENERIC_TYPE iter, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			this.iter = iter;
+			this.operator = operator;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				if(first) {
+					first = false;
+					value = iter.NEXT();
+				}
+				else {
+					value = operator.APPLY_VALUE(value, iter.NEXT());
+				}
+			}
+			if(!iter.hasNext()) {
+				setResult(value);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			operator = null;
+#if TYPE_OBJECT
+			value = null;
+#endif
+		}
+	}
+	
+	private static class MatchTask KEY_GENERIC_TYPE extends BaseBooleanTask
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		PREDICATE KEY_GENERIC_TYPE filter;
+		int type;
+		
+		public MatchTask(ITERATOR KEY_GENERIC_TYPE iter, PREDICATE KEY_GENERIC_TYPE filter, int type) {
+			this.iter = iter;
+			this.filter = filter;
+			this.type = type;
+			if(type < 0 || type > 2) throw new IllegalArgumentException("Type is not allowed has to be between 0-2");
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			switch(type) {
+				case 0:
+					while(shouldRun() && iter.hasNext()) {
+#if TYPE_OBJECT
+						if(filter.getBoolean(iter.NEXT())) {
+#else
+						if(filter.GET_VALUE(iter.NEXT())) {
+#endif
+							setResult(true);
+							return true;
+						}
+					}
+					break;
+				case 1:
+					while(shouldRun() && iter.hasNext()) {
+#if TYPE_OBJECT
+						if(filter.getBoolean(iter.NEXT())) {
+#else
+						if(filter.GET_VALUE(iter.NEXT())) {
+#endif
+							setResult(false);
+							return true;
+						}
+					}
+					break;
+				case 2:
+					while(shouldRun() && iter.hasNext()) {
+#if TYPE_OBJECT
+						if(!filter.getBoolean(iter.NEXT())) {
+#else
+						if(!filter.GET_VALUE(iter.NEXT())) {
+#endif
+							setResult(false);
+							return true;
+						}
+					}
+					break;
+			}
+			if(!iter.hasNext()) {
+				setResult(type >= 1);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			filter = null;
+		}
+	}
+	
+	private static class FindFirstTask KEY_GENERIC_TYPE extends BASE_TASK KEY_GENERIC_TYPE
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		PREDICATE KEY_GENERIC_TYPE filter;
+		
+		public FindFirstTask(ITERATOR KEY_GENERIC_TYPE iter, PREDICATE KEY_GENERIC_TYPE filter) {
+			this.iter = iter;
+			this.filter = filter;
+		}
+
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				KEY_TYPE entry = iter.NEXT();
+#if TYPE_OBJECT
+				if(filter.getBoolean(iter.NEXT())) {
+#else
+				if(filter.GET_VALUE(iter.NEXT())) {
+#endif
+					setResult(entry);
+					return true;
+				}
+			}
+			return !iter.hasNext();
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			filter = null;
+		}
+	}
+	
+	private static class CountTask KEY_GENERIC_TYPE extends BaseIntTask
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		PREDICATE KEY_GENERIC_TYPE filter;
+		int counted = 0;
+		
+		public CountTask(ITERATOR KEY_GENERIC_TYPE iter, PREDICATE KEY_GENERIC_TYPE filter) {
+			this.iter = iter;
+			this.filter = filter;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				if(filter.TEST_VALUE(iter.NEXT())) {
+					counted++;
+				}
+			}
+			if(!iter.hasNext())
+			{
+				setResult(counted);
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			filter = null;
+		}
+	}
+	
+	private static class CollectTask KSS_GENERIC_TYPE<V, T extends COLLECTION KEY_SPECIAL_GENERIC_TYPE<V>> extends BaseObjectTask<T>
+	{
+		ITERATOR KEY_SPECIAL_GENERIC_TYPE<V> iter;
+		T collection;
+		
+		public CollectTask(ITERATOR KEY_SPECIAL_GENERIC_TYPE<V> iter, T collection) {
+			this.iter = iter;
+			this.collection = collection;
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				collection.add(iter.NEXT());
+			}
+			if(!iter.hasNext()) {
+				setResult(collection);
+				collection = null;
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+		}
+	}
+	
+	private static class ForEachTask<T> extends BaseObjectTask<Void>
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		CONSUMER KEY_GENERIC_TYPE listener;
+		
+		public ForEachTask(ITERATOR KEY_GENERIC_TYPE iter, CONSUMER KEY_GENERIC_TYPE listener) {
+			this.iter = iter;
+			this.listener = listener;
+		}
+
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				listener.accept(iter.NEXT());
+			}
+			return !iter.hasNext();
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+			listener = null;
+		}
+	}
+	
+	/**
+	 * Base Task of the Actions that can be performed.
+	 * Allows to simplify the actions that get executed.
+	 * @Type(T)
+	 */
+	public abstract static class BASE_TASK KEY_GENERIC_TYPE implements TASK KEY_GENERIC_TYPE
+	{
+		private static final int CREATED = 0;
+		private static final int RUNNING = 1;
+		private static final int PAUSING = 2;
+		private static final int PAUSED = 3;
+		private static final int FINISHING = 4;
+		private static final int FINISHED = 5;
+		private static final int EXCEPTIONALLY = 6;
+		private static final int CANCELLED = 7;
+		private volatile WaitNode waiter;
+		private volatile int state = CREATED;
+		Consumer<TASK KEY_GENERIC_TYPE> callback;
+		Executor executor = SanityChecks::invokeAsyncTask;
+		KEY_TYPE result;
+		Throwable excpetion;
+		
+		void withCallback(Consumer<TASK KEY_GENERIC_TYPE> callback) {
+			this.callback = callback;
+		}
+		
+		void withExecutor(Executor executor) {
+			this.executor = executor;
+		}
+		
+		void begin() {
+			executor.execute(this);
+		}
+		
+		protected abstract boolean execute() throws Exception;
+		
+		protected void onCompletion() {
+			if(callback != null) {
+				callback.accept(this);
+				callback = null;
+			}
+			executor = null;
+		}
+		
+		protected void setResult(KEY_TYPE result) {
+			this.result = result;
+		}
+		
+		@Override
+		public void run() {
+			state = RUNNING;
+			try {
+				if(execute()) {
+					state = FINISHING;
+					finishCompletion(FINISHED);
+				}
+				else if(state == PAUSING) {
+					state = PAUSED;
+				}
+			}
+			catch(Exception e) {
+				state = EXCEPTIONALLY;
+				this.excpetion = e;
+				finishCompletion(EXCEPTIONALLY);
+			}
+		}
+		
+	    private void finishCompletion(int nextState) {
+	    	WaitNode current = waiter;
+	    	waiter = null;
+	    	while(current != null) {
+                Thread t = current.thread;
+                if (t != null) {
+                    current.thread = null;
+                    LockSupport.unpark(t);
+                }
+                WaitNode next = current.next;
+                if (next == null)
+                    break;
+                current.next = null;
+                current = next;
+	    	}
+	    	state = nextState;
+	    	onCompletion();
+	    }
+		
+		@Override
+		public boolean cancel(boolean cancelIfRunnning) {
+			if(state == RUNNING && !cancelIfRunnning) return false;
+			state = CANCELLED;
+			finishCompletion(CANCELLED);
+			return true;
+		}
+		
+		@Override
+		public KEY_TYPE GET_KEY() throws InterruptedException, ExecutionException {
+	        int s = state;
+	        return report(s <= FINISHING ? awaitDone(false, 0L) : s);
+		}
+		
+		@Override
+		public KEY_TYPE GET_KEY(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+			if (unit == null) throw new NullPointerException();
+			int s = state;
+			if (s <= FINISHING && (s = awaitDone(true, unit.toNanos(timeout))) <= FINISHING) throw new TimeoutException();
+	        return report(s);
+		}
+		
+		private KEY_TYPE report(int s) throws ExecutionException {
+			if (s == FINISHED) return result;
+			if (s >= CANCELLED) throw new CancellationException();
+			throw new ExecutionException(excpetion);
+	    }
+		
+		private int awaitDone(boolean timed, long nanos) throws InterruptedException {
+			final long deadline = timed ? System.nanoTime() + nanos : 0L;
+			WaitNode q = null;
+			boolean queued = false;
+			while(true) {
+				if(Thread.interrupted()) {
+					removeWaiter(q);
+					throw new InterruptedException();
+				}
+				int s = state;
+				if(s > FINISHING) {
+					if(q != null) q.thread = null;
+					return s;
+				}
+				else if(s == FINISHING) Thread.yield();
+				else if(q == null) q = new WaitNode();
+				else if(!queued) {
+					q.next = waiter;
+					waiter = q;
+					queued = true;
+				}
+				else if(timed) {
+					nanos = deadline - System.nanoTime();
+					if(nanos <= 0L) {
+						removeWaiter(q);
+						return state;
+					}
+					LockSupport.parkNanos(this, nanos);
+				}
+				else LockSupport.park(this);
+			}
+		}
+		
+		private void removeWaiter(WaitNode node) {
+			if(node == null) return;
+			node.thread = null;
+			retry:
+			while(true) {
+				for(WaitNode prev = null, current = waiter, next = null; current != null; current = next) {
+					next = current.next;
+					if(current.thread != null) prev = current;
+					else if(prev != null) {
+						prev.next = next;
+						if(prev.thread == null) continue retry; //Previous element got removed which means another thread was editing this while we were editing.
+					}
+					else if(waiter == current) {
+						waiter = next;
+						continue retry;
+					}
+				}
+				break;
+			}
+		}
+		
+		@Override
+		public boolean isCancelled() { return state >= CANCELLED; }
+		@Override
+		public boolean isDone() { return state >= FINISHING; }
+		@Override
+		public boolean isPaused() { return state == PAUSED; }
+		@Override
+		public boolean isSuccessful() { return state == FINISHED; }
+		protected boolean shouldRun() { return state == RUNNING; }
+		
+		@Override
+		public void pause() {
+			if(state == PAUSED || state == PAUSING || state >= FINISHING) return;
+			state = PAUSING;
+		}
+		
+		@Override
+		public void awaitPausing() {
+			if(state == PAUSED) return;
+			pause();
+			if(state == PAUSING) {
+				while(state == PAUSING) {
+					Thread.yield();
+				}
+			}
+		}
+		
+		@Override
+		public void resume() {
+			if(state != PAUSED && state != PAUSING) return;
+			if(state == PAUSING) {
+				while(state == PAUSING) {
+					Thread.yield();
+				}
+			}
+			state = RUNNING;
+			executor.execute(this);
+		}
+		
+		static final class WaitNode {
+			volatile Thread thread;
+			volatile WaitNode next;
+			
+			WaitNode() {
+				thread = Thread.currentThread();
+			}
+		}
+	}
+}

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

@@ -18,6 +18,7 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.sets.SORTED_SET;
 import speiger.src.collections.PACKAGE.utils.COLLECTIONS.EmptyCollection;
 import speiger.src.collections.PACKAGE.utils.COLLECTIONS.SynchronizedCollection;
@@ -95,6 +96,29 @@ public class SETS
 		return s instanceof SynchronizedSortedSet ? s : (s instanceof ITrimmable ? new SynchronizedSortedTrimSetBRACES(s, mutex) : new SynchronizedSortedSetBRACES(s, mutex));
 	}
 	
+	/**
+	 * Creates a Synchronized OrderedSet while preserving the ITrimmable interface
+	 * @param s the set that should be synchronized
+	 * @Type(T)
+	 * @return a OrderedSet that is synchronized
+	 * @note if the set is already synchronized then it will just self return it
+	 */
+	public static GENERIC_KEY_BRACES ORDERED_SET KEY_GENERIC_TYPE synchronize(ORDERED_SET KEY_GENERIC_TYPE s) {
+		return s instanceof SynchronizedOrderedSet ? s : (s instanceof ITrimmable ? new SynchronizedOrderedTrimSetBRACES(s) : new SynchronizedOrderedSetBRACES(s));
+	}
+	
+	/**
+	 * Creates a Synchronized OrderedSet while preserving the ITrimmable interface
+	 * @param s the set that should be synchronized
+	 * @param mutex controller for access
+	 * @Type(T)
+	 * @return a OrderedSet that is synchronized
+	 * @note if the set is already synchronized then it will just self return it
+	 */
+	public static GENERIC_KEY_BRACES ORDERED_SET KEY_GENERIC_TYPE synchronize(ORDERED_SET KEY_GENERIC_TYPE s, Object mutex) {
+		return s instanceof SynchronizedOrderedSet ? s : (s instanceof ITrimmable ? new SynchronizedOrderedTrimSetBRACES(s, mutex) : new SynchronizedOrderedSetBRACES(s, mutex));
+	}
+	
 	/**
 	 * Creates a Synchronized NavigableSet while preserving the ITrimmable interface
 	 * @param s the set that should be synchronized
@@ -138,6 +162,16 @@ public class SETS
 		return s instanceof UnmodifiableSortedSet ? s : new UnmodifiableSortedSetBRACES(s);
 	}
 	
+	/**
+	 * Creates Unmodifyable OrderedSet wrapper
+	 * @param s OrderedSet that should be made unmodifiable
+	 * @Type(T)
+	 * @return a UnmodifyableOrderedSet, if the set is already unmodifiable then it returns itself
+	 */
+	public static GENERIC_KEY_BRACES ORDERED_SET KEY_GENERIC_TYPE unmodifiable(ORDERED_SET KEY_GENERIC_TYPE s) {
+		return s instanceof UnmodifiableOrderedSet ? s : new UnmodifiableOrderedSetBRACES(s);
+	}
+	
 	/**
 	 * Creates Unmodifyable NavigableSet wrapper
 	 * @param s navigableSet that should be made unmodifiable
@@ -173,6 +207,9 @@ public class SETS
 #endif
 		@Override
 		public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#if TYPE_OBJECT
+		public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#endif
 		@Override
 		public ITERATOR KEY_GENERIC_TYPE iterator()
 		{
@@ -200,6 +237,9 @@ public class SETS
 #if !TYPE_OBJECT
 		@Override
 		public boolean remove(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+#else
+		@Override
+		public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 #endif
 		@Override
 		public EmptySet KEY_GENERIC_TYPE copy() { return this; }
@@ -278,6 +318,39 @@ public class SETS
 		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { return SETS.unmodifiable(n.tailSet(fromElement)); }
 	}
 	
+	private static class UnmodifiableOrderedSet KEY_GENERIC_TYPE extends UnmodifiableSet KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
+	{
+		ORDERED_SET KEY_GENERIC_TYPE s;
+		UnmodifiableOrderedSet(ORDERED_SET KEY_GENERIC_TYPE c)
+		{
+			super(c);
+			s = c;
+		}
+		
+		@Override
+		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(s.iterator()); }
+		@Override
+		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return ITERATORS.unmodifiable(s.iterator(fromElement)); }
+		@Override
+		public ORDERED_SET KEY_GENERIC_TYPE copy() { return s.copy(); }
+		@Override
+		public KEY_TYPE FIRST_KEY() { return s.FIRST_KEY(); }
+		@Override
+		public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); }
+		@Override
+		public KEY_TYPE LAST_KEY() { return s.LAST_KEY(); }
+		@Override
+		public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); }
+	}
+	
 	private static class UnmodifiableSortedSet KEY_GENERIC_TYPE extends UnmodifiableSet KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
 	{
 		SORTED_SET KEY_GENERIC_TYPE s;
@@ -288,47 +361,37 @@ public class SETS
 		}
 		
 		@Override
+		@Deprecated
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
+		@Deprecated
 		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
+		@Deprecated
 		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
+		@Deprecated
 		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return s.comparator(); }
-		
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(s.iterator()); }
-		
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return ITERATORS.unmodifiable(s.iterator(fromElement)); }
-		
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE copy() { return s.copy(); }
-		
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { return SETS.unmodifiable(s.subSet(fromElement, toElement)); }
-		
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { return SETS.unmodifiable(s.headSet(toElement)); }
-		
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { return SETS.unmodifiable(s.tailSet(fromElement)); }
-		
 		@Override
 		public KEY_TYPE FIRST_KEY() { return s.FIRST_KEY(); }
-		
 		@Override
 		public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public KEY_TYPE LAST_KEY() { return s.LAST_KEY(); }
-		
 		@Override
 		public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); }
 	}
@@ -347,6 +410,11 @@ public class SETS
 			s = c;
 		}
 		
+#if TYPE_OBJECT
+		@Override
+		public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		
+#endif
 		@Override
 		public SET KEY_GENERIC_TYPE copy() { return s.copy(); }
 		
@@ -490,47 +558,96 @@ public class SETS
 		}
 
 		@Override
+		@Deprecated
 		public boolean addAndMoveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToFirst(o); } }
-
 		@Override
+		@Deprecated
 		public boolean addAndMoveToLast(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToLast(o); } }
-
 		@Override
+		@Deprecated
 		public boolean moveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.moveToFirst(o); } }
-
 		@Override
+		@Deprecated
 		public boolean moveToLast(KEY_TYPE o) { synchronized(mutex) { return s.moveToLast(o); } }
-
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator(){ synchronized(mutex) { return s.comparator(); } }
-
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator() { synchronized(mutex) { return s.iterator(); } }
-
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { synchronized(mutex) { return s.iterator(fromElement); } }
-		
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } }
-		
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return SETS.synchronize(s.subSet(fromElement, toElement), mutex); } }
-
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return SETS.synchronize(s.headSet(toElement), mutex); } }
-
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return SETS.synchronize(s.tailSet(fromElement), mutex); } }
-
 		@Override
 		public KEY_TYPE FIRST_KEY() { synchronized(mutex) { return s.FIRST_KEY(); } }
-
 		@Override
 		public KEY_TYPE POLL_FIRST_KEY() { synchronized(mutex) { return s.POLL_FIRST_KEY(); } }
-
 		@Override
 		public KEY_TYPE LAST_KEY() { synchronized(mutex) { return s.LAST_KEY(); } }
+		@Override
+		public KEY_TYPE POLL_LAST_KEY() { synchronized(mutex) { return s.POLL_LAST_KEY(); } }
+	}
 	
+	private static class SynchronizedOrderedTrimSet KEY_GENERIC_TYPE extends SynchronizedOrderedSet KEY_GENERIC_TYPE implements ITrimmable
+	{
+		ITrimmable trim;
+		
+		SynchronizedOrderedTrimSet(ORDERED_SET KEY_GENERIC_TYPE c) {
+			super(c);
+			trim = (ITrimmable)c;
+		}
+		
+		SynchronizedOrderedTrimSet(ORDERED_SET KEY_GENERIC_TYPE c, Object mutex) {
+			super(c, mutex);
+			trim = (ITrimmable)c;
+		}
+		
+		@Override
+		public boolean trim(int size) { synchronized(mutex) { return trim.trim(size); } }
+		
+		@Override
+		public void clearAndTrim(int size) { synchronized(mutex) { trim.clearAndTrim(size); } }
+	}
+	
+	private static class SynchronizedOrderedSet KEY_GENERIC_TYPE extends SynchronizedSet KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
+	{
+		ORDERED_SET KEY_GENERIC_TYPE s;
+		
+		SynchronizedOrderedSet(ORDERED_SET KEY_GENERIC_TYPE c) {
+			super(c);
+			s = c;
+		}
+		
+		SynchronizedOrderedSet(ORDERED_SET KEY_GENERIC_TYPE c, Object mutex) {
+			super(c, mutex);
+			s = c;
+		}
+
+		@Override
+		public boolean addAndMoveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToFirst(o); } }
+		@Override
+		public boolean addAndMoveToLast(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToLast(o); } }
+		@Override
+		public boolean moveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.moveToFirst(o); } }
+		@Override
+		public boolean moveToLast(KEY_TYPE o) { synchronized(mutex) { return s.moveToLast(o); } }
+		@Override
+		public BI_ITERATOR KEY_GENERIC_TYPE iterator() { synchronized(mutex) { return s.iterator(); } }
+		@Override
+		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { synchronized(mutex) { return s.iterator(fromElement); } }
+		@Override
+		public ORDERED_SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } }
+		@Override
+		public KEY_TYPE FIRST_KEY() { synchronized(mutex) { return s.FIRST_KEY(); } }
+		@Override
+		public KEY_TYPE POLL_FIRST_KEY() { synchronized(mutex) { return s.POLL_FIRST_KEY(); } }
+		@Override
+		public KEY_TYPE LAST_KEY() { synchronized(mutex) { return s.LAST_KEY(); } }
 		@Override
 		public KEY_TYPE POLL_LAST_KEY() { synchronized(mutex) { return s.POLL_LAST_KEY(); } }
 	}
@@ -570,6 +687,11 @@ public class SETS
 			s = c;
 		}
 		
+#if TYPE_OBJECT
+		@Override
+		public KEY_TYPE addOrGet(KEY_TYPE o) { synchronized(mutex) { return s.addOrGet(o); } }
+		
+#endif
 		@Override
 		public SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } }
 		

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

@@ -32,6 +32,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 #if !TYPE_BOOLEAN
 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;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.SET;
@@ -161,6 +162,28 @@ public class MAPS
 	 */
 	public static GENERIC_KEY_VALUE_BRACES SORTED_MAP KEY_VALUE_GENERIC_TYPE synchronize(SORTED_MAP KEY_VALUE_GENERIC_TYPE map, Object mutex) { return map instanceof SynchronizedSortedMap ? map : new SynchronizedSortedMapKV_BRACES(map, mutex); }
 	
+	/**
+	 * Helper function that creates a Helper wrapper to synchronize access into the OrderedMap.
+	 * @param map the OrderedMap that should be synchronized
+	 * @Type(T)
+	 * @ValueType(V)
+	 * @return a synchronized OrderedMap
+	 * @note if the inputted map is already synchronized then it will just return it instead
+	 * @note iterators do not support synchronization
+	 */
+	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof SynchronizedOrderedMap ? map : new SynchronizedOrderedMapKV_BRACES(map); }
+	/**
+	 * Helper function that creates a Helper wrapper to synchronize access with custom access control into the OrderedMap.
+	 * @param map the OrderedMap that should be synchronized
+	 * @param mutex the object that controls access
+	 * @Type(T)
+	 * @ValueType(V)
+	 * @return a synchronized OrderedMap
+	 * @note if the inputted map is already synchronized then it will just return it instead
+	 * @note iterators do not support synchronization
+	 */
+	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map, Object mutex) { return map instanceof SynchronizedOrderedMap ? map : new SynchronizedOrderedMapKV_BRACES(map, mutex); }
+	
 	/**
 	 * Helper function that creates a Helper wrapper to synchronize access into the NavigableMap.
 	 * @param map the NavigableMap that should be synchronized
@@ -192,6 +215,17 @@ public class MAPS
 	 * @note if the inputted map is already unmodifiable then it will just return it instead
 	 */
 	public static GENERIC_KEY_VALUE_BRACES MAP KEY_VALUE_GENERIC_TYPE unmodifiable(MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof UnmodifyableMap ? map : new UnmodifyableMapKV_BRACES(map); }
+	
+	/**
+	 * A Helper function that creates a Helper wrapper to only allow Read Access into the OrderedMap
+	 * @param map the OrderedMap that should be made Unmodifiable
+	 * @Type(T)
+	 * @ValueType(V)
+	 * @return a unmodifiable OrderedMap
+	 * @note if the inputted OrderedMap is already unmodifiable then it will just return it instead
+	 */
+	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof UnmodifyableOrderedMap ? map : new UnmodifyableOrderedMapKV_BRACES(map); }
+	
 	/**
 	 * A Helper function that creates a Helper wrapper to only allow Read Access into the SortedMap
 	 * @param map the SortedMap that should be made Unmodifiable
@@ -201,6 +235,7 @@ public class MAPS
 	 * @note if the inputted SortedMap is already unmodifiable then it will just return it instead
 	 */
 	public static GENERIC_KEY_VALUE_BRACES SORTED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable(SORTED_MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof UnmodifyableSortedMap ? map : new UnmodifyableSortedMapKV_BRACES(map); }
+	
 	/**
 	 * A Helper function that creates a Helper wrapper to only allow Read Access into NavigableMap Map
 	 * @param map the NavigableMap that should be made Unmodifiable
@@ -210,6 +245,7 @@ public class MAPS
 	 * @note if the inputted NavigableMap is already unmodifiable then it will just return it instead
 	 */
 	public static GENERIC_KEY_VALUE_BRACES NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE unmodifiable(NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof UnmodifyableNavigableMap ? map : new UnmodifyableNavigableMapKV_BRACES(map); }
+	
 	/**
 	 * A Helper function that creates a Unmodifyable Entry
 	 * @param entry the Entry that should be made unmodifiable
@@ -262,6 +298,8 @@ public class MAPS
 #if VALUE_PRIMITIVES
 		@Override
 		public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
 #endif
 		@Override
 		public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@@ -310,6 +348,8 @@ public class MAPS
 #if VALUE_PRIMITIVES
 		@Override
 		public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
 #endif
 		@Override
 		public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@@ -424,14 +464,14 @@ public class MAPS
 	}
 	
 	/**
-	 * The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
+	 * The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
 	 * @Type(T)
 	 * @ValueType(V)
 	 */
-	public static class UnmodifyableSortedMap KEY_VALUE_GENERIC_TYPE extends UnmodifyableMap KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE {
+	public static class UnmodifyableOrderedMap KEY_VALUE_GENERIC_TYPE extends UnmodifyableMap KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE {
-		SORTED_MAP KEY_VALUE_GENERIC_TYPE map;
+		ORDERED_MAP KEY_VALUE_GENERIC_TYPE map;
 		
-		UnmodifyableSortedMap(SORTED_MAP KEY_VALUE_GENERIC_TYPE map) {
+		UnmodifyableOrderedMap(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map) {
 			super(map);
 			this.map = map;
 		}
@@ -449,6 +489,53 @@ public class MAPS
 		@Override
 		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 		@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(); }
+		@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(); }
+		@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(); }
+	}
+	
+	/**
+	 * The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
+	 * @Type(T)
+	 * @ValueType(V)
+	 */
+	public static class UnmodifyableSortedMap KEY_VALUE_GENERIC_TYPE extends UnmodifyableMap KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE {
+		SORTED_MAP KEY_VALUE_GENERIC_TYPE map;
+		
+		UnmodifyableSortedMap(SORTED_MAP KEY_VALUE_GENERIC_TYPE map) {
+			super(map);
+			this.map = map;
+		}
+		
+		@Override
+		@Deprecated
+		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
+		@Override
+		@Deprecated
+		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
+		@Override
+		@Deprecated
+		public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
+		@Override
+		@Deprecated
+		public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
+		@Override
+		@Deprecated
+		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
+		@Override
+		@Deprecated
+		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
+		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return map.comparator(); }
 		@Override
 		public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { return MAPS.unmodifiable(map.subMap(fromKey, toKey)); }
@@ -494,6 +581,8 @@ public class MAPS
 #if VALUE_PRIMITIVES
 		@Override
 		public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
+		@Override
+		public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
 #endif
 		@Override
 		public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@@ -680,6 +769,52 @@ public class MAPS
 #endif
 	}
 	
+	/**
+	 * The Synchronized Ordered Map implementation used by the synchronizedMap helper function
+	 * @Type(T)
+	 * @ValueType(V)
+	 */
+	public static class SynchronizedOrderedMap KEY_VALUE_GENERIC_TYPE extends SynchronizedMap KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE {
+		ORDERED_MAP KEY_VALUE_GENERIC_TYPE map;
+		
+		SynchronizedOrderedMap(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map) {
+			super(map);
+			this.map = map;
+		}
+		
+		SynchronizedOrderedMap(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map, Object mutex) {
+			super(map, mutex);
+			this.map = map;
+		}
+		
+		@Override
+		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToFirst(key, value); } }
+		@Override
+		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } }
+		@Override
+		public boolean moveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.moveToFirst(key); } }
+		@Override
+		public boolean moveToLast(KEY_TYPE key) { synchronized(mutex) { return map.moveToLast(key); } }
+		@Override
+		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.getAndMoveToFirst(key); } }
+		@Override
+		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { synchronized(mutex) { return map.getAndMoveToLast(key); } }
+		@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(); } }
+		@Override
+		public KEY_TYPE LAST_ENTRY_KEY() { synchronized(mutex) { return map.LAST_ENTRY_KEY(); } }
+		@Override
+		public KEY_TYPE POLL_LAST_ENTRY_KEY() { synchronized(mutex) { return map.POLL_LAST_ENTRY_KEY(); } }
+		@Override
+		public VALUE_TYPE FIRST_ENTRY_VALUE() { synchronized(mutex) { return map.FIRST_ENTRY_VALUE(); } }
+		@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(); }
+	}
+	
 	/**
 	 * The Synchronized Sorted Map implementation used by the synchronizedMap helper function
 	 * @Type(T)
@@ -699,16 +834,22 @@ public class MAPS
 		}
 		
 		@Override
+		@Deprecated
 		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToFirst(key, value); } }
 		@Override
+		@Deprecated
 		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } }
 		@Override
+		@Deprecated
 		public boolean moveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.moveToFirst(key); } }
 		@Override
+		@Deprecated
 		public boolean moveToLast(KEY_TYPE key) { synchronized(mutex) { return map.moveToLast(key); } }
 		@Override
+		@Deprecated
 		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.getAndMoveToFirst(key); } }
 		@Override
+		@Deprecated
 		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { synchronized(mutex) { return map.getAndMoveToLast(key); } }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { synchronized(mutex) { return map.comparator(); } }
@@ -791,6 +932,8 @@ public class MAPS
 #if VALUE_PRIMITIVES
 		@Override
 		public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.addTo(key, value); } }
+		@Override
+		public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.subFrom(key, value); } }
 		public void addToAll(MAP KEY_VALUE_GENERIC_TYPE m) { synchronized(mutex) { map.addToAll(m); } }
 #endif
 		@Override

src/main/java/speiger/src/collections/utils/SanityChecks.java

@@ -104,6 +104,14 @@ public class SanityChecks
 		getPool().execute(task);
 	}
 	
+	/**
+	 * A Helper method to start a Async Task. This method will not await the finalization of said task
+	 * @param task the Task to invoke
+	 */
+	public static void invokeAsyncTask(Runnable task) {
+		getPool().execute(task);
+	}
+	
 	/**
 	 * Helper method to control what ForkJoinPool is being used for any given task.
 	 * @note this method is not thread-save. It is only there to provide control over how Library specific Threaded tasks are handled.

src/test/java/speiger/src/collections/ints/base/BaseInt2IntOrderedMapTest.java

@@ -0,0 +1,75 @@
+package speiger.src.collections.ints.base;
+
+import java.util.EnumSet;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap;
+import speiger.src.collections.tests.OrderedMapTests;
+
+@SuppressWarnings("javadoc")
+public abstract class BaseInt2IntOrderedMapTest extends BaseInt2IntMapTest
+{
+	@Override
+	public abstract Int2IntOrderedMap createMap(int[] keys, int[] values);
+	@Override
+	public abstract Int2IntOrderedMap createEmptyMap();
+	
+	public EnumSet<OrderedMapTests> getValidOrderedMapTests() { return EnumSet.allOf(OrderedMapTests.class); }
+
+	@Test
+	public void testPutMove()
+	{
+		if(!getValidOrderedMapTests().contains(OrderedMapTests.PUT_MOVE)) return;
+		Int2IntOrderedMap map = createMap(TEST_ARRAY, TEST_ARRAY);
+		Assert.assertEquals(0, map.putAndMoveToFirst(120, -1));
+		Assert.assertEquals(120, map.firstIntKey());
+		Assert.assertEquals(-1, map.firstIntValue());
+		Assert.assertEquals(0, map.putAndMoveToLast(121, -2));
+		Assert.assertEquals(121, map.lastIntKey());
+		Assert.assertEquals(-2, map.lastIntValue());
+	}
+	
+	@Test
+	public void testMove()
+	{
+		if(!getValidOrderedMapTests().contains(OrderedMapTests.MOVE)) return;
+		Int2IntOrderedMap map = createMap(TEST_ARRAY, TEST_ARRAY);
+		Assert.assertTrue(map.moveToFirst(99));
+		Assert.assertFalse(map.moveToFirst(99));
+		Assert.assertEquals(99, map.firstIntKey());
+		Assert.assertTrue(map.moveToLast(0));
+		Assert.assertFalse(map.moveToLast(0));
+		Assert.assertEquals(0, map.lastIntKey());
+	}
+	
+	@Test
+	public void testGetMove()
+	{
+		if(!getValidOrderedMapTests().contains(OrderedMapTests.GET_MOVE)) return;
+		Int2IntOrderedMap map = createMap(TEST_ARRAY, TEST_ARRAY);
+		Assert.assertNotEquals(99, map.firstIntValue());
+		Assert.assertEquals(99, map.getAndMoveToFirst(99));
+		Assert.assertEquals(99, map.firstIntValue());
+		Assert.assertNotEquals(0, map.lastIntValue());
+		Assert.assertEquals(0, map.getAndMoveToLast(0));
+		Assert.assertEquals(0, map.lastIntValue());
+	}
+	
+	@Test
+	public void testFirst()
+	{
+		if(!getValidOrderedMapTests().contains(OrderedMapTests.FIRST)) return;
+		Int2IntOrderedMap map = createMap(TEST_ARRAY, TEST_ARRAY);
+		Assert.assertEquals(map.pollFirstIntKey(), 0);
+	}
+	
+	@Test
+	public void testLast()
+	{
+		if(!getValidOrderedMapTests().contains(OrderedMapTests.LAST)) return;
+		Int2IntOrderedMap map = createMap(TEST_ARRAY, TEST_ARRAY);
+		Assert.assertEquals(map.pollLastIntKey(), 99);
+	}
+}

src/test/java/speiger/src/collections/ints/base/BaseInt2IntSortedMapTest.java

@@ -18,45 +18,6 @@ public abstract class BaseInt2IntSortedMapTest extends BaseInt2IntMapTest
 	
 	public EnumSet<SortedMapTests> getValidSortedMapTests() { return EnumSet.allOf(SortedMapTests.class); }
 	
-	@Test
-	public void testPutMove()
-	{
-		if(!getValidSortedMapTests().contains(SortedMapTests.PUT_MOVE)) return;
-		Int2IntSortedMap map = createMap(TEST_ARRAY, TEST_ARRAY);
-		Assert.assertEquals(0, map.putAndMoveToFirst(120, -1));
-		Assert.assertEquals(120, map.firstIntKey());
-		Assert.assertEquals(-1, map.firstIntValue());
-		Assert.assertEquals(0, map.putAndMoveToLast(121, -2));
-		Assert.assertEquals(121, map.lastIntKey());
-		Assert.assertEquals(-2, map.lastIntValue());
-	}
-	
-	@Test
-	public void testMove()
-	{
-		if(!getValidSortedMapTests().contains(SortedMapTests.MOVE)) return;
-		Int2IntSortedMap map = createMap(TEST_ARRAY, TEST_ARRAY);
-		Assert.assertTrue(map.moveToFirst(99));
-		Assert.assertFalse(map.moveToFirst(99));
-		Assert.assertEquals(99, map.firstIntKey());
-		Assert.assertTrue(map.moveToLast(0));
-		Assert.assertFalse(map.moveToLast(0));
-		Assert.assertEquals(0, map.lastIntKey());
-	}
-	
-	@Test
-	public void testGetMove()
-	{
-		if(!getValidSortedMapTests().contains(SortedMapTests.GET_MOVE)) return;
-		Int2IntSortedMap map = createMap(TEST_ARRAY, TEST_ARRAY);
-		Assert.assertNotEquals(99, map.firstIntValue());
-		Assert.assertEquals(99, map.getAndMoveToFirst(99));
-		Assert.assertEquals(99, map.firstIntValue());
-		Assert.assertNotEquals(0, map.lastIntValue());
-		Assert.assertEquals(0, map.getAndMoveToLast(0));
-		Assert.assertEquals(0, map.lastIntValue());
-	}
-	
 	@Test
 	public void testFirst()
 	{

src/test/java/speiger/src/collections/ints/base/BaseIntOrderedSetTest.java

@@ -0,0 +1,63 @@
+package speiger.src.collections.ints.base;
+
+import java.util.EnumSet;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import speiger.src.collections.ints.sets.IntOrderedSet;
+import speiger.src.collections.tests.OrderedSetTest;
+
+@SuppressWarnings("javadoc")
+public abstract class BaseIntOrderedSetTest extends BaseIntCollectionTest
+{
+	@Override
+	protected abstract IntOrderedSet create(int[] data);
+	
+	protected EnumSet<OrderedSetTest> getValidOrderedSetTests() { return EnumSet.allOf(OrderedSetTest.class); }
+	
+	@Test
+	public void addMoveTest() {
+		if(getValidOrderedSetTests().contains(OrderedSetTest.ADD_MOVE)) {
+			IntOrderedSet set = create(TEST_ARRAY);
+			Assert.assertTrue(set.addAndMoveToFirst(1050));
+			Assert.assertFalse(set.addAndMoveToLast(5));
+		}
+	}
+	
+	@Test
+	public void moveTest() {
+		if(getValidOrderedSetTests().contains(OrderedSetTest.MOVE)) {
+			IntOrderedSet set = create(TEST_ARRAY);
+			Assert.assertTrue(set.moveToFirst(5));
+			Assert.assertFalse(set.moveToFirst(5));
+			Assert.assertTrue(set.moveToLast(5));
+			Assert.assertFalse(set.moveToLast(5));
+		}
+	}
+	
+	@Test
+	public void peekTest() {
+		if(getValidOrderedSetTests().contains(OrderedSetTest.PEEK)) {
+			IntOrderedSet set = create(TEST_ARRAY);
+			Assert.assertEquals(set.firstInt(), 0);
+			Assert.assertEquals(set.lastInt(), 99);
+		}
+	}
+	
+	@Test
+	public void pollTest() {
+		if(getValidOrderedSetTests().contains(OrderedSetTest.POLL)) {
+			IntOrderedSet set = create(TEST_ARRAY);
+			for(int i = 0;i<100;i++)
+			{
+				Assert.assertEquals(i, set.pollFirstInt());
+			}
+			set = create(TEST_ARRAY);
+			for(int i = 99;i>=0;i--)
+			{
+				Assert.assertEquals(i, set.pollLastInt());
+			}
+		}
+	}
+}

src/test/java/speiger/src/collections/ints/base/BaseIntPriorityQueueTest.java

@@ -82,6 +82,24 @@ public abstract class BaseIntPriorityQueueTest extends BaseIntIterableTest
 		}
 	}
 	
+	@Test
+	public void testUnorderedPeek() {
+		EnumSet<PriorityQueueTest> valid = getValidPriorityQueueTests();
+		if(valid.contains(PriorityQueueTest.IN_OUT) && valid.contains(PriorityQueueTest.PEEK) && !isUnsortedRead()) {
+			IntPriorityQueue queue = create(EMPTY_ARRAY);
+			for(int i = 0;i<100;i++) {
+				queue.enqueue(i);
+			}
+			for(int i = 0;i<25;i++) {
+				queue.dequeue();
+				queue.enqueue(i);
+			}
+			for(int i = 0;i<100;i++) {
+				Assert.assertEquals((i+25) % 100, queue.peek(i));
+			}
+		}
+	}
+	
 	@Test
 	@SuppressWarnings("deprecation")
 	public void testToArray() {

src/test/java/speiger/src/collections/ints/base/BaseIntSortedSetTest.java

@@ -16,26 +16,6 @@ public abstract class BaseIntSortedSetTest extends BaseIntCollectionTest
 	
 	protected EnumSet<SortedSetTest> getValidSortedSetTests() { return EnumSet.allOf(SortedSetTest.class); }
 	
-	@Test
-	public void addMoveTest() {
-		if(getValidSortedSetTests().contains(SortedSetTest.ADD_MOVE)) {
-			IntSortedSet set = create(TEST_ARRAY);
-			Assert.assertTrue(set.addAndMoveToFirst(1050));
-			Assert.assertFalse(set.addAndMoveToLast(5));
-		}
-	}
-	
-	@Test
-	public void moveTest() {
-		if(getValidSortedSetTests().contains(SortedSetTest.MOVE)) {
-			IntSortedSet set = create(TEST_ARRAY);
-			Assert.assertTrue(set.moveToFirst(5));
-			Assert.assertFalse(set.moveToFirst(5));
-			Assert.assertTrue(set.moveToLast(5));
-			Assert.assertFalse(set.moveToLast(5));
-		}
-	}
-	
 	@Test
 	public void peekTest() {
 		if(getValidSortedSetTests().contains(SortedSetTest.PEEK)) {

src/test/java/speiger/src/collections/ints/maps/Int2IntAVLTreeMapTest.java

@@ -1,18 +1,12 @@
 package speiger.src.collections.ints.maps;
 
-import java.util.EnumSet;
-
 import speiger.src.collections.ints.base.BaseInt2IntNavigableMapTest;
 import speiger.src.collections.ints.maps.impl.tree.Int2IntAVLTreeMap;
 import speiger.src.collections.ints.maps.interfaces.Int2IntNavigableMap;
-import speiger.src.collections.tests.SortedMapTests;
 
 @SuppressWarnings("javadoc")
 public class Int2IntAVLTreeMapTest extends BaseInt2IntNavigableMapTest
 {	
-	@Override
-	public EnumSet<SortedMapTests> getValidSortedMapTests() { return EnumSet.complementOf(EnumSet.of(SortedMapTests.GET_MOVE, SortedMapTests.MOVE, SortedMapTests.PUT_MOVE)); }
-	
 	@Override
 	public Int2IntNavigableMap createMap(int[] keys, int[] values)
 	{

src/test/java/speiger/src/collections/ints/maps/Int2IntArrayMapTest.java

@@ -1,20 +1,20 @@
 package speiger.src.collections.ints.maps;
 
-import speiger.src.collections.ints.base.BaseInt2IntSortedMapTest;
+import speiger.src.collections.ints.base.BaseInt2IntOrderedMapTest;
 import speiger.src.collections.ints.maps.impl.misc.Int2IntArrayMap;
-import speiger.src.collections.ints.maps.interfaces.Int2IntSortedMap;
+import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap;
 
 @SuppressWarnings("javadoc")
-public class Int2IntArrayMapTest extends BaseInt2IntSortedMapTest
+public class Int2IntArrayMapTest extends BaseInt2IntOrderedMapTest
 {	
 	@Override
-	public Int2IntSortedMap createMap(int[] keys, int[] values)
+	public Int2IntOrderedMap createMap(int[] keys, int[] values)
 	{
 		return new Int2IntArrayMap(keys, values);
 	}
 	
 	@Override
-	public Int2IntSortedMap createEmptyMap()
+	public Int2IntOrderedMap createEmptyMap()
 	{
 		return new Int2IntArrayMap();
 	}

src/test/java/speiger/src/collections/ints/maps/Int2IntLinkedOpenCustomHashMapTest.java

@@ -1,26 +1,20 @@
 package speiger.src.collections.ints.maps;
 
-import java.util.EnumSet;
+import speiger.src.collections.ints.base.BaseInt2IntOrderedMapTest;
-
-import speiger.src.collections.ints.base.BaseInt2IntSortedMapTest;
 import speiger.src.collections.ints.maps.impl.customHash.Int2IntLinkedOpenCustomHashMap;
-import speiger.src.collections.ints.maps.interfaces.Int2IntSortedMap;
+import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap;
-import speiger.src.collections.tests.SortedMapTests;
 
 @SuppressWarnings("javadoc")
-public class Int2IntLinkedOpenCustomHashMapTest extends BaseInt2IntSortedMapTest
+public class Int2IntLinkedOpenCustomHashMapTest extends BaseInt2IntOrderedMapTest
 {	
 	@Override
-	public EnumSet<SortedMapTests> getValidSortedMapTests() { return EnumSet.complementOf(EnumSet.of(SortedMapTests.SUB_MAP, SortedMapTests.TAIL_MAP, SortedMapTests.HEAD_MAP)); }
+	public Int2IntOrderedMap createMap(int[] keys, int[] values)
-	
-	@Override
-	public Int2IntSortedMap createMap(int[] keys, int[] values)
 	{
 		return new Int2IntLinkedOpenCustomHashMap(keys, values, STRATEGY);
 	}
 	
 	@Override
-	public Int2IntSortedMap createEmptyMap()
+	public Int2IntOrderedMap createEmptyMap()
 	{
 		return new Int2IntLinkedOpenCustomHashMap(STRATEGY);
 	}

src/test/java/speiger/src/collections/ints/maps/Int2IntLinkedOpenHashMapTest.java

@@ -1,26 +1,20 @@
 package speiger.src.collections.ints.maps;
 
-import java.util.EnumSet;
+import speiger.src.collections.ints.base.BaseInt2IntOrderedMapTest;
-
-import speiger.src.collections.ints.base.BaseInt2IntSortedMapTest;
 import speiger.src.collections.ints.maps.impl.hash.Int2IntLinkedOpenHashMap;
-import speiger.src.collections.ints.maps.interfaces.Int2IntSortedMap;
+import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap;
-import speiger.src.collections.tests.SortedMapTests;
 
 @SuppressWarnings("javadoc")
-public class Int2IntLinkedOpenHashMapTest extends BaseInt2IntSortedMapTest
+public class Int2IntLinkedOpenHashMapTest extends BaseInt2IntOrderedMapTest
 {
 	@Override
-	public EnumSet<SortedMapTests> getValidSortedMapTests() { return EnumSet.complementOf(EnumSet.of(SortedMapTests.SUB_MAP, SortedMapTests.TAIL_MAP, SortedMapTests.HEAD_MAP)); }
+	public Int2IntOrderedMap createMap(int[] keys, int[] values)
-	
-	@Override
-	public Int2IntSortedMap createMap(int[] keys, int[] values)
 	{
 		return new Int2IntLinkedOpenHashMap(keys, values);
 	}
 	
 	@Override
-	public Int2IntSortedMap createEmptyMap()
+	public Int2IntOrderedMap createEmptyMap()
 	{
 		return new Int2IntLinkedOpenHashMap();
 	}

src/test/java/speiger/src/collections/ints/maps/Int2IntRBTreeMapTest.java

@@ -1,18 +1,12 @@
 package speiger.src.collections.ints.maps;
 
-import java.util.EnumSet;
-
 import speiger.src.collections.ints.base.BaseInt2IntNavigableMapTest;
 import speiger.src.collections.ints.maps.impl.tree.Int2IntRBTreeMap;
 import speiger.src.collections.ints.maps.interfaces.Int2IntNavigableMap;
-import speiger.src.collections.tests.SortedMapTests;
 
 @SuppressWarnings("javadoc")
 public class Int2IntRBTreeMapTest extends BaseInt2IntNavigableMapTest
 {
-	@Override
-	public EnumSet<SortedMapTests> getValidSortedMapTests() { return EnumSet.complementOf(EnumSet.of(SortedMapTests.GET_MOVE, SortedMapTests.MOVE, SortedMapTests.PUT_MOVE)); }
-	
 	@Override
 	public Int2IntNavigableMap createMap(int[] keys, int[] values)
 	{

src/test/java/speiger/src/collections/ints/sets/IntAVLTreeSetTests.java

@@ -1,9 +1,6 @@
 package speiger.src.collections.ints.sets;
 
-import java.util.EnumSet;
-
 import speiger.src.collections.ints.base.BaseIntNavigableSetTest;
-import speiger.src.collections.tests.SortedSetTest;
 
 @SuppressWarnings("javadoc")
 public class IntAVLTreeSetTests extends BaseIntNavigableSetTest
@@ -12,7 +9,4 @@ public class IntAVLTreeSetTests extends BaseIntNavigableSetTest
 	protected IntNavigableSet create(int[] data) {
 		return new IntAVLTreeSet(data);
 	}
-	
-	@Override
-	protected EnumSet<SortedSetTest> getValidSortedSetTests() { return EnumSet.of(SortedSetTest.PEEK, SortedSetTest.POLL, SortedSetTest.HEAD_SET, SortedSetTest.SUB_SET, SortedSetTest.TAIL_SET);}
 }

src/test/java/speiger/src/collections/ints/sets/IntArraySetTests.java

@@ -1,10 +1,10 @@
 package speiger.src.collections.ints.sets;
 
-import speiger.src.collections.ints.base.BaseIntSortedSetTest;
+import speiger.src.collections.ints.base.BaseIntOrderedSetTest;
 
 @SuppressWarnings("javadoc")
-public class IntArraySetTests extends BaseIntSortedSetTest
+public class IntArraySetTests extends BaseIntOrderedSetTest
 {
 	@Override
-	protected IntSortedSet create(int[] data) { return new IntArraySet(data.clone()); }
+	protected IntOrderedSet create(int[] data) { return new IntArraySet(data.clone()); }
 }

src/test/java/speiger/src/collections/ints/sets/IntHashSetTests.java

@@ -3,21 +3,14 @@ package speiger.src.collections.ints.sets;
 import java.util.EnumSet;
 
 import speiger.src.collections.ints.base.BaseIntCollectionTest;
-import speiger.src.collections.ints.base.BaseIntSortedSetTest;
+import speiger.src.collections.ints.base.BaseIntOrderedSetTest;
 import speiger.src.collections.ints.collections.IntCollection;
 import speiger.src.collections.ints.utils.IntStrategy;
 import speiger.src.collections.tests.CollectionTest;
-import speiger.src.collections.tests.SortedSetTest;
 
 @SuppressWarnings("javadoc")
 public class IntHashSetTests
 {
-	public static abstract class BaseIntOpenHashSetTests extends BaseIntSortedSetTest
-	{
-		@Override
-		protected EnumSet<SortedSetTest> getValidSortedSetTests() { return EnumSet.of(SortedSetTest.ADD_MOVE, SortedSetTest.MOVE, SortedSetTest.PEEK, SortedSetTest.POLL); }
-	}
-	
 	public static class IntOpenHashSetTests extends BaseIntCollectionTest
 	{
 		@Override
@@ -32,10 +25,10 @@ public class IntHashSetTests
 		}
 	}
 	
-	public static class IntLinkedOpenHashSetTests extends BaseIntOpenHashSetTests
+	public static class IntLinkedOpenHashSetTests extends BaseIntOrderedSetTest
 	{
 		@Override
-		protected IntSortedSet create(int[] data) { return new IntLinkedOpenHashSet(data); }
+		protected IntOrderedSet create(int[] data) { return new IntLinkedOpenHashSet(data); }
 	}
 	
 	public static class IntOpenCustomHashSetTests extends BaseIntCollectionTest
@@ -52,10 +45,10 @@ public class IntHashSetTests
 		}
 	}
 	
-	public static class IntLinkedOpenCustomHashSetTests extends BaseIntOpenHashSetTests
+	public static class IntLinkedOpenCustomHashSetTests extends BaseIntOrderedSetTest
 	{
 		@Override
-		protected IntSortedSet create(int[] data) { return new IntLinkedOpenCustomHashSet(data, new DefaultStrategy()); }
+		protected IntOrderedSet create(int[] data) { return new IntLinkedOpenCustomHashSet(data, new DefaultStrategy()); }
 	}
 	
 	public static class DefaultStrategy implements IntStrategy

src/test/java/speiger/src/collections/ints/sets/IntRBTreeSetTests.java

@@ -1,9 +1,6 @@
 package speiger.src.collections.ints.sets;
 
-import java.util.EnumSet;
-
 import speiger.src.collections.ints.base.BaseIntNavigableSetTest;
-import speiger.src.collections.tests.SortedSetTest;
 
 @SuppressWarnings("javadoc")
 public class IntRBTreeSetTests extends BaseIntNavigableSetTest
@@ -13,7 +10,4 @@ public class IntRBTreeSetTests extends BaseIntNavigableSetTest
 	protected IntNavigableSet create(int[] data) {
 		return new IntRBTreeSet(data);
 	}
-	
-	@Override
-	protected EnumSet<SortedSetTest> getValidSortedSetTests() { return EnumSet.of(SortedSetTest.PEEK, SortedSetTest.POLL, SortedSetTest.HEAD_SET, SortedSetTest.SUB_SET, SortedSetTest.TAIL_SET);}
 }

src/test/java/speiger/src/collections/objects/list/ObjectListTests.java

@@ -12,6 +12,10 @@ import com.google.common.collect.testing.features.ListFeature;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
+import speiger.src.collections.ints.lists.ImmutableIntList;
+import speiger.src.collections.ints.lists.IntArrayList;
+import speiger.src.collections.ints.lists.IntLinkedList;
+import speiger.src.collections.ints.lists.IntList;
 import speiger.src.collections.objects.lists.ImmutableObjectList;
 import speiger.src.collections.objects.lists.ObjectArrayList;
 import speiger.src.collections.objects.lists.ObjectLinkedList;
@@ -25,19 +29,28 @@ public class ObjectListTests extends TestCase
 		suite.addTest(suite("ArrayList", T -> new ObjectArrayList<>(T)));
 		suite.addTest(suite("LinkedList", T -> new ObjectLinkedList<>(T)));
 		suite.addTest(immutableSuite("ImmutableList", T -> new ImmutableObjectList<>(T)));
+		suite.addTest(intSuite("IntArrayList", IntArrayList::new));
+		suite.addTest(intSuite("IntLinkedList", IntLinkedList::new));
+		suite.addTest(intImmutableSuite("IntImmutableList", ImmutableIntList::new));
 		return suite;
 	}
 	
-	public static Test suite(String name, Function<String[], List<String>> factory)
+	public static Test intSuite(String name, Function<int[], IntList> factory) {
-	{
+		return ListTestSuiteBuilder.using(new TestIntListGenerator(factory)).named(name).withFeatures(ListFeature.GENERAL_PURPOSE, CollectionSize.ANY).createTestSuite();
+	}
+	
+	public static Test intImmutableSuite(String name, Function<int[], IntList> factory) {
+		return ListTestSuiteBuilder.using(new TestIntListGenerator(factory)).named(name).withFeatures(CollectionSize.ANY).createTestSuite();
+	}
+	
+	public static Test suite(String name, Function<String[], List<String>> factory) {
 		return ListTestSuiteBuilder.using(new TestStringListGenerator() {
 			@Override
 			protected List<String> create(String[] elements) { return factory.apply(elements); }
 		}).named(name).withFeatures(ListFeature.GENERAL_PURPOSE, CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
 	}
 	
-	public static Test immutableSuite(String name, Function<String[], List<String>> factory)
+	public static Test immutableSuite(String name, Function<String[], List<String>> factory) {
-	{
 		return ListTestSuiteBuilder.using(new TestStringListGenerator() {
 			@Override
 			protected List<String> create(String[] elements) { return factory.apply(elements); }

src/test/java/speiger/src/collections/objects/list/TestIntListGenerator.java

@@ -0,0 +1,50 @@
+package speiger.src.collections.objects.list;
+
+import java.util.List;
+import java.util.function.Function;
+
+import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.SampleElements.Ints;
+import com.google.common.collect.testing.TestListGenerator;
+
+import speiger.src.collections.ints.lists.IntList;
+
+@SuppressWarnings("javadoc")
+public class TestIntListGenerator implements TestListGenerator<Integer>
+{
+	Function<int[], IntList> function;
+	
+	public TestIntListGenerator(Function<int[], IntList> function)
+	{
+		this.function = function;
+	}
+
+	@Override
+	public SampleElements<Integer> samples()
+	{
+		return new Ints();
+	}
+	
+	@Override
+	public List<Integer> create(Object... elements)
+	{
+		int[] array = new int[elements.length];
+		int i = 0;
+		for(Object e : elements)
+		{
+			array[i++] = ((Integer)e).intValue();
+		}
+		return function.apply(array);
+	}		
+	@Override
+	public Integer[] createArray(int length)
+	{
+		return new Integer[length];
+	}
+	
+	@Override
+	public List<Integer> order(List<Integer> insertionOrder)
+	{
+		return insertionOrder;
+	}
+}

src/test/java/speiger/src/collections/objects/map/ObjectMapTests.java

@@ -2,14 +2,17 @@ package speiger.src.collections.objects.map;
 
 import java.util.Comparator;
 import java.util.Map;
+import java.util.NavigableMap;
 import java.util.Objects;
 import java.util.function.BiFunction;
 import java.util.function.Supplier;
 
 import com.google.common.collect.testing.AnEnum;
 import com.google.common.collect.testing.MapTestSuiteBuilder;
+import com.google.common.collect.testing.NavigableMapTestSuiteBuilder;
 import com.google.common.collect.testing.TestEnumMapGenerator;
 import com.google.common.collect.testing.TestStringMapGenerator;
+import com.google.common.collect.testing.TestStringSortedMapGenerator;
 import com.google.common.collect.testing.features.CollectionFeature;
 import com.google.common.collect.testing.features.CollectionSize;
 import com.google.common.collect.testing.features.MapFeature;
@@ -39,10 +42,10 @@ public class ObjectMapTests extends TestCase
 		suite.addTest(suite("LinkedHashMap", Object2ObjectLinkedOpenHashMap::new, true));
 		suite.addTest(suite("CustomHashMap", () -> new Object2ObjectOpenCustomHashMap<>(Strategy.INSTANCE), true));
 		suite.addTest(suite("LinkedCustomHashMap", () -> new Object2ObjectLinkedOpenCustomHashMap<>(Strategy.INSTANCE), true));
-		suite.addTest(suite("RBTreeMap_NonNull", Object2ObjectRBTreeMap::new, false));
+		suite.addTest(navigableSuite("RBTreeMap_NonNull", Object2ObjectRBTreeMap::new, false));
-		suite.addTest(suite("AVLTreeMap_NonNull", Object2ObjectAVLTreeMap::new, false));
+		suite.addTest(navigableSuite("AVLTreeMap_NonNull", Object2ObjectAVLTreeMap::new, false));
-		suite.addTest(suite("RBTreeMap_Null", () -> new Object2ObjectRBTreeMap<String, String>(Comparator.nullsFirst(Comparator.naturalOrder())), true));
+		suite.addTest(navigableSuite("RBTreeMap_Null", () -> new Object2ObjectRBTreeMap<>(new NullFriendlyComparator()), true));
-		suite.addTest(suite("AVLTreeMap_Null", () -> new Object2ObjectAVLTreeMap<String, String>(Comparator.nullsFirst(Comparator.naturalOrder())), true));
+		suite.addTest(navigableSuite("AVLTreeMap_Null", () -> new Object2ObjectAVLTreeMap<>(new NullFriendlyComparator()), true));
 		suite.addTest(immutableSuit("ImmutableMap", ImmutableObject2ObjectOpenHashMap::new));
 		suite.addTest(suite("ArrayMap", Object2ObjectArrayMap::new, true));
 		suite.addTest(enumSuite("EnumMap", () -> new Enum2ObjectMap<>(AnEnum.class)));
@@ -66,6 +69,22 @@ public class ObjectMapTests extends TestCase
 		return builder.createTestSuite();
 	}
 	
+	public static Test navigableSuite(String name, Supplier<NavigableMap<String, String>> factory, boolean allowNull)
+	{
+		MapTestSuiteBuilder<String, String> builder = NavigableMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() {
+			@Override
+			protected NavigableMap<String, String> create(Map.Entry<String, String>[] entries) {
+				NavigableMap<String, String> map = factory.get();
+				for(Map.Entry<String, String> entry : entries) {
+					map.put(entry.getKey(), entry.getValue());
+				}
+				return map;
+			}
+		}).named(name).withFeatures(CollectionSize.ANY, MapFeature.GENERAL_PURPOSE, MapFeature.ALLOWS_NULL_VALUES, CollectionFeature.SUPPORTS_ITERATOR_REMOVE);
+		if(allowNull) builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS, MapFeature.ALLOWS_ANY_NULL_QUERIES);
+		return builder.createTestSuite();
+	}
+	
 	public static Test immutableSuit(String name, BiFunction<String[], String[], Map<String, String>> factory)  {
 		MapTestSuiteBuilder<String, String> builder = MapTestSuiteBuilder.using(new TestStringMapGenerator() {
 			@Override
@@ -97,6 +116,14 @@ public class ObjectMapTests extends TestCase
 		return builder.createTestSuite();
 	}
 	
+	private static final class NullFriendlyComparator implements Comparator<String>
+	{
+		@Override
+		public int compare(String left, String right) {
+			return String.valueOf(left).compareTo(String.valueOf(right));
+		}
+	}
+	
 	private static class Strategy implements ObjectStrategy<String>
 	{
 		static final Strategy INSTANCE = new Strategy();

src/test/java/speiger/src/collections/objects/set/ObjectSetTests.java

@@ -1,12 +1,19 @@
 package speiger.src.collections.objects.set;
 
+import java.util.Arrays;
 import java.util.Comparator;
+import java.util.List;
+import java.util.NavigableSet;
 import java.util.Objects;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
+import com.google.common.collect.testing.NavigableSetTestSuiteBuilder;
 import com.google.common.collect.testing.SetTestSuiteBuilder;
+import com.google.common.collect.testing.TestIntegerSetGenerator;
 import com.google.common.collect.testing.TestStringSetGenerator;
+import com.google.common.collect.testing.TestStringSortedSetGenerator;
 import com.google.common.collect.testing.features.CollectionFeature;
 import com.google.common.collect.testing.features.CollectionSize;
 import com.google.common.collect.testing.features.SetFeature;
@@ -14,6 +21,17 @@ import com.google.common.collect.testing.features.SetFeature;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
+import speiger.src.collections.ints.sets.ImmutableIntOpenHashSet;
+import speiger.src.collections.ints.sets.IntAVLTreeSet;
+import speiger.src.collections.ints.sets.IntArraySet;
+import speiger.src.collections.ints.sets.IntLinkedOpenCustomHashSet;
+import speiger.src.collections.ints.sets.IntLinkedOpenHashSet;
+import speiger.src.collections.ints.sets.IntNavigableSet;
+import speiger.src.collections.ints.sets.IntOpenCustomHashSet;
+import speiger.src.collections.ints.sets.IntOpenHashSet;
+import speiger.src.collections.ints.sets.IntRBTreeSet;
+import speiger.src.collections.ints.sets.IntSet;
+import speiger.src.collections.ints.utils.IntStrategy;
 import speiger.src.collections.objects.sets.ImmutableObjectOpenHashSet;
 import speiger.src.collections.objects.sets.ObjectAVLTreeSet;
 import speiger.src.collections.objects.sets.ObjectArraySet;
@@ -27,24 +45,63 @@ import speiger.src.collections.objects.utils.ObjectStrategy;
 @SuppressWarnings("javadoc")
 public class ObjectSetTests extends TestCase
 {
+	@SuppressWarnings("deprecation")
 	public static Test suite()
 	{
 		TestSuite suite = new TestSuite("Sets");
+		suite.addTest(intSuite("IntHashSet", IntOpenHashSet::new));
+		suite.addTest(intSuite("IntCustomHashSet", () -> new IntOpenCustomHashSet(IntegerStrategy.INSTANCE)));
+		suite.addTest(intSuite("IntLinkedHashSet", IntLinkedOpenHashSet::new));
+		suite.addTest(intSuite("IntLinkedCustomHashSet", () -> new IntLinkedOpenCustomHashSet(IntegerStrategy.INSTANCE)));
+		suite.addTest(intSuite("IntArraySet", IntArraySet::new));
+		suite.addTest(intImmutableSuite("ImmutableHashSet", ImmutableIntOpenHashSet::new));
+		suite.addTest(intNavigableSuite("IntRBTreeSet", IntRBTreeSet::new));
+		suite.addTest(intNavigableSuite("IntAVLTreeSet", IntAVLTreeSet::new));
 		suite.addTest(suite("HashSet", ObjectOpenHashSet::new, true));
 		suite.addTest(suite("LinkedHashSet", ObjectLinkedOpenHashSet::new, true));
 		suite.addTest(suite("CustomHashSet", T -> new ObjectOpenCustomHashSet<>(T, Strategy.INSTANCE), true));
 		suite.addTest(suite("LinkedCustomHashSet", T -> new ObjectLinkedOpenCustomHashSet<>(T, Strategy.INSTANCE), true));
 		suite.addTest(immutableSuite("ImmutableHashSet", ImmutableObjectOpenHashSet::new));
 		suite.addTest(suite("ArraySet", ObjectArraySet::new, true));
-		suite.addTest(suite("RBTreeSet_NonNull", ObjectRBTreeSet::new, false));
+		suite.addTest(navigableSuite("RBTreeSet_NonNull", ObjectRBTreeSet::new, false));
-		suite.addTest(suite("AVLTreeSet_NonNull", ObjectAVLTreeSet::new, false));
+		suite.addTest(navigableSuite("AVLTreeSet_NonNull", ObjectAVLTreeSet::new, false));
-		suite.addTest(suite("RBTreeSet_Null", T -> new ObjectRBTreeSet<>(T, Comparator.nullsFirst(Comparator.naturalOrder())), true));
+		suite.addTest(navigableSuite("RBTreeSet_Null", T -> new ObjectRBTreeSet<>(T, Comparator.nullsFirst(Comparator.naturalOrder())), true));
-		suite.addTest(suite("AVLTreeSet_Null", T -> new ObjectAVLTreeSet<>(T, Comparator.nullsFirst(Comparator.naturalOrder())), true));
+		suite.addTest(navigableSuite("AVLTreeSet_Null", T -> new ObjectAVLTreeSet<>(T, Comparator.nullsFirst(Comparator.naturalOrder())), true));
 		return suite;
 	}
 	
-	public static Test suite(String name, Function<String[], Set<String>> factory, boolean allowNull)
+	public static Test intSuite(String name, Supplier<IntSet> factory) {
-	{
+		SetTestSuiteBuilder<Integer> generator = SetTestSuiteBuilder.using(new TestIntegerSetGenerator() {
+			@Override
+			protected Set<Integer> create(Integer[] elements) {
+				IntSet set = factory.get();
+				set.addAll(Arrays.asList(elements));
+				return set;
+			}
+		}).named(name).withFeatures(CollectionSize.ANY, SetFeature.GENERAL_PURPOSE);
+		return generator.createTestSuite();
+	}
+	
+	public static Test intNavigableSuite(String name, Supplier<IntNavigableSet> factory) {
+		SetTestSuiteBuilder<Integer> generator = NavigableSetTestSuiteBuilder.using(new TestIntegerNavigableSetGenerator() {
+			@Override
+			protected NavigableSet<Integer> create(Integer[] elements) {
+				IntNavigableSet set = factory.get();
+				set.addAll(Arrays.asList(elements));
+				return set;
+			}
+		}).named(name).withFeatures(CollectionSize.ANY, SetFeature.GENERAL_PURPOSE, CollectionFeature.SUBSET_VIEW);
+		return generator.createTestSuite();
+	}
+	
+	public static Test intImmutableSuite(String name, Function<List<Integer>, IntSet> factory) {
+		return SetTestSuiteBuilder.using(new TestIntegerSetGenerator() {
+			@Override
+			protected Set<Integer> create(Integer[] elements) { return factory.apply(Arrays.asList(elements)); }
+		}).named(name).withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite();
+	}
+	
+	public static Test suite(String name, Function<String[], Set<String>> factory, boolean allowNull) {
 		SetTestSuiteBuilder<String> generator = SetTestSuiteBuilder.using(new TestStringSetGenerator() {
 			@Override
 			protected Set<String> create(String[] elements) { return factory.apply(elements); }
@@ -53,17 +110,23 @@ public class ObjectSetTests extends TestCase
 		return generator.createTestSuite();
 	}
 	
+	public static Test navigableSuite(String name, Function<String[], NavigableSet<String>> factory, boolean allowNull) {
+		SetTestSuiteBuilder<String> generator = NavigableSetTestSuiteBuilder.using(new TestStringSortedSetGenerator() {
+			@Override
+			protected NavigableSet<String> create(String[] elements) { return factory.apply(elements); }
+		}).named(name).withFeatures(CollectionSize.ANY, SetFeature.GENERAL_PURPOSE);
+		if(allowNull) generator.withFeatures(CollectionFeature.ALLOWS_NULL_VALUES);
+		return generator.createTestSuite();
+	}
 	
-	public static Test immutableSuite(String name, Function<String[], Set<String>> factory)
+	public static Test immutableSuite(String name, Function<String[], Set<String>> factory) {
-	{
 		return SetTestSuiteBuilder.using(new TestStringSetGenerator() {
 			@Override
 			protected Set<String> create(String[] elements) { return factory.apply(elements); }
 		}).named(name).withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES).createTestSuite();
 	}
 	
-	private static class Strategy implements ObjectStrategy<String>
+	private static class Strategy implements ObjectStrategy<String> {
-	{
 		static final Strategy INSTANCE = new Strategy();
 		
 		@Override
@@ -75,6 +138,20 @@ public class ObjectSetTests extends TestCase
 		public boolean equals(String key, String value) {
 			return Objects.equals(key, value);
 		}
+	}
+	
+	private static class IntegerStrategy implements IntStrategy {
+		static final IntegerStrategy INSTANCE = new IntegerStrategy();
+		
+		@Override
+		public int hashCode(int o) {
+			return Integer.hashCode(o);
+		}
+
+		@Override
+		public boolean equals(int key, int value) {
+			return key == value;
+		}
 		
 	}
 }

src/test/java/speiger/src/collections/objects/set/TestIntegerNavigableSetGenerator.java

@@ -0,0 +1,32 @@
+package speiger.src.collections.objects.set;
+
+import java.util.SortedSet;
+
+import com.google.common.collect.testing.TestIntegerSortedSetGenerator;
+import com.google.common.collect.testing.TestSortedSetGenerator;
+
+@SuppressWarnings("javadoc")
+public abstract class TestIntegerNavigableSetGenerator extends TestIntegerSortedSetGenerator implements TestSortedSetGenerator<Integer>
+{
+	@Override
+	protected abstract SortedSet<Integer> create(Integer[] elements);
+
+	@Override
+	public SortedSet<Integer> create(Object... elements) {
+	    Integer[] array = new Integer[elements.length];
+	    int i = 0;
+	    for (Object e : elements) {
+	      array[i++] = (Integer) e;
+	    }
+	    return create(array);
+	}
+
+	@Override
+	public Integer belowSamplesLesser() { return -2; }
+	@Override
+	public Integer belowSamplesGreater() { return -1; }
+	@Override
+	public Integer aboveSamplesLesser() { return 5; }
+	@Override
+	public Integer aboveSamplesGreater() { return 6; }		
+}

src/test/java/speiger/src/collections/tests/OrderedMapTests.java

@@ -0,0 +1,11 @@
+package speiger.src.collections.tests;
+
+@SuppressWarnings("javadoc")
+public enum OrderedMapTests
+{
+	PUT_MOVE,
+	MOVE,
+	GET_MOVE,
+	FIRST,
+	LAST;
+}

src/test/java/speiger/src/collections/tests/OrderedSetTest.java

@@ -0,0 +1,10 @@
+package speiger.src.collections.tests;
+
+@SuppressWarnings("javadoc")
+public enum OrderedSetTest
+{
+	ADD_MOVE,
+	MOVE,
+	PEEK,
+	POLL;
+}

src/test/java/speiger/src/collections/tests/SortedMapTests.java

@@ -3,9 +3,6 @@ package speiger.src.collections.tests;
 @SuppressWarnings("javadoc")
 public enum SortedMapTests
 {
-	PUT_MOVE,
-	MOVE,
-	GET_MOVE,
 	FIRST,
 	LAST,
 	SUB_MAP,

src/test/java/speiger/src/collections/tests/SortedSetTest.java

@@ -3,8 +3,6 @@ package speiger.src.collections.tests;
 @SuppressWarnings("javadoc")
 public enum SortedSetTest
 {
-	ADD_MOVE,
-	MOVE,
 	PEEK,
 	POLL,
 	SUB_SET,