Merge remote-tracking branch 'Github/master'

Refactoring and Deprecating SortedMap/Sets
- Added: OrderedMap/Set - Added: All Relevant functions into Ordered interface - Changed: Marked all Relevant SortedMap/Set functions Deprecated until 0.6.0 - Fixed: All code that was relevant to this
2021-12-25 03:49:45 +01:00 · 2021-12-25 03:46:51 +01:00 · 2021-12-19 21:19:28 +01:00 · 2021-12-16 14:03:39 +01:00 · 2021-12-16 13:46:55 +01:00 · 2021-12-14 09:05:25 +01:00
53 changed files with 6049 additions and 4863 deletions
@@ -1,5 +1,17 @@
 # Changelog of versions
 ### 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.
@@ -1,208 +1,201 @@
                                 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
-"Object" form shall mean any form resulting from mechanical transformation
+          distribution, then any Derivative Works that You distribute must
-or translation of a Source form, including but not limited to compiled object
+          include a readable copy of the attribution notices contained
-code, generated documentation, and conversions to other media types.
+          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
-"Work" shall mean the work of authorship, whether in Source or Object form,
+          documentation, if provided along with the Derivative Works; or,
-made available under the License, as indicated by a copyright notice that
+          within a display generated by the Derivative Works, if and
-is included in or attached to the work (an example is provided in the Appendix
+          wherever such third-party notices normally appear. The contents
-below).
+          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
-"Derivative Works" shall mean any work, whether in Source or Object form,
+          that such additional attribution notices cannot be construed
 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.
 "Contribution" shall mean any work of authorship, including the original version
 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."
 "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.
 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
+      You may add Your own copyright statement to Your modifications and
-additional or different license terms and conditions for use, reproduction,
+      may provide additional or different license terms and conditions
-or distribution of Your modifications, or for any such Derivative Works as
+      for use, reproduction, or distribution of Your modifications, or
-a whole, provided Your use, reproduction, and distribution of the Work otherwise
+      for any such Derivative Works as a whole, provided Your use,
-complies with the conditions stated in this License.
+      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
+   5. Submission of Contributions. Unless You explicitly state otherwise,
-Contribution intentionally submitted for inclusion in the Work by You to the
+      any Contribution intentionally submitted for inclusion in the Work
-Licensor shall be under the terms and conditions of this License, without
+      by You to the Licensor shall be under the terms and conditions of
-any additional terms or conditions. Notwithstanding the above, nothing herein
+      this License, without any additional terms or conditions.
-shall supersede or modify the terms of any separate license agreement you
+      Notwithstanding the above, nothing herein shall supersede or modify
-may have executed with Licensor regarding such Contributions.
+      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,
+   6. Trademarks. This License does not grant permission to use the trade
-trademarks, service marks, or product names of the Licensor, except as required
+      names, trademarks, service marks, or product names of the Licensor,
-for reasonable and customary use in describing the origin of the Work and
+      except as required for reasonable and customary use in describing the
-reproducing the content of the NOTICE file.
+      origin of the Work and reproducing the content of the NOTICE file.
-7. Disclaimer of Warranty. Unless required by applicable law or agreed to
+   7. Disclaimer of Warranty. Unless required by applicable law or
-in writing, Licensor provides the Work (and each Contributor provides its
+      agreed to in writing, Licensor provides the Work (and each
-Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+      Contributor provides its Contributions) on an "AS IS" BASIS,
-KIND, either express or implied, including, without limitation, any warranties
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR
+      implied, including, without limitation, any warranties or conditions
-A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-of using or redistributing the Work and assume any risks associated with Your
+      PARTICULAR PURPOSE. You are solely responsible for determining the
-exercise of permissions under this License.
+      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
+   8. Limitation of Liability. In no event and under no legal theory,
-in tort (including negligence), contract, or otherwise, unless required by
+      whether in tort (including negligence), contract, or otherwise,
-applicable law (such as deliberate and grossly negligent acts) or agreed to
+      unless required by applicable law (such as deliberate and grossly
-in writing, shall any Contributor be liable to You for damages, including
+      negligent acts) or agreed to in writing, shall any Contributor be
-any direct, indirect, special, incidental, or consequential damages of any
+      liable to You for damages, including any direct, indirect, special,
-character arising as a result of this License or out of the use or inability
+      incidental, or consequential damages of any character arising as a
-to use the Work (including but not limited to damages for loss of goodwill,
+      result of this License or out of the use or inability to use the
-work stoppage, computer failure or malfunction, or any and all other commercial
+      Work (including but not limited to damages for loss of goodwill,
-damages or losses), even if such Contributor has been advised of the possibility
+      work stoppage, computer failure or malfunction, or any and all
-of such damages.
+      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
+   9. Accepting Warranty or Additional Liability. While redistributing
-or Derivative Works thereof, You may choose to offer, and charge a fee for,
+      the Work or Derivative Works thereof, You may choose to offer,
-acceptance of support, warranty, indemnity, or other liability obligations
+      and charge a fee for, acceptance of support, warranty, indemnity,
-and/or rights consistent with this License. However, in accepting such obligations,
+      or other liability obligations and/or rights consistent with this
-You may act only on Your own behalf and on Your sole responsibility, not on
+      License. However, in accepting such obligations, You may act only
-behalf of any other Contributor, and only if You agree to indemnify, defend,
+      on Your own behalf and on Your sole responsibility, not on behalf
-and hold each Contributor harmless for any liability incurred by, or claims
+      of any other Contributor, and only if You agree to indemnify,
-asserted against, such Contributor by reason of your accepting any such warranty
+      defend, and hold each Contributor harmless for any liability
-or additional liability. END OF TERMS AND CONDITIONS
+      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
+      To apply the Apache License to your work, attach the following
-notice, with the fields enclosed by brackets "[]" replaced with your own identifying
+      boilerplate notice, with the fields enclosed by brackets "[]"
-information. (Don't include the brackets!) The text should be enclosed in
+      replaced with your own identifying information. (Don't include
-the appropriate comment syntax for the file format. We also recommend that
+      the brackets!)  The text should be enclosed in the appropriate
-a file or class name and description of purpose be included on the same "printed
+      comment syntax for the file format. We also recommend that a
-page" as the copyright notice for easier identification within third-party
+      file or class name and description of purpose be included on the
-archives.
+      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.
@@ -6,11 +6,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 +22,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 +43,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.
@@ -95,13 +92,15 @@ repositories {
    }
 }
 dependencies {
-	compile 'de.speiger:Primitive-Collections:0.5.0'
+	compile 'de.speiger:Primitive-Collections:0.5.2'
 }
 ```
 Direct:
 | Version 	| Jar                                                                                                                          	| Sources                                                                                                                              	| Java Doc                                                                                                                             	|
 |---------	|------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|
 | 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 +133,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.
@@ -18,7 +18,7 @@ repositories {
 }
 archivesBaseName = 'Primitive Collections'
-version = '0.5.0';
+version = '0.5.2';
 sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8'
@@ -46,7 +46,6 @@ dependencies {
 	runtimeOnly 'de.speiger:Simple-Code-Generator:1.0.5'
    testImplementation 'junit:junit:4.12'
    testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
 }
 task generateSource(type: JavaExec) {
@@ -218,6 +218,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,6 +227,7 @@ 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");
@@ -73,7 +73,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 +88,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) 
@@ -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;
@@ -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;
@@ -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;
@@ -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;
@@ -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);
@@ -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); }
 }
@@ -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);
@@ -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();
 	}
@@ -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;
@@ -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);
 	}
@@ -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;
@@ -499,27 +499,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 +576,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;
@@ -257,7 +257,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;
@@ -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;
@@ -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;
@@ -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
@@ -252,7 +252,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 +270,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;
@@ -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
 }
@@ -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);
@@ -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
@@ -278,6 +312,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 +355,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(); }
 	}
@@ -490,47 +547,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(); } }
 	}
@@ -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
@@ -424,14 +460,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 +485,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)); }
@@ -680,6 +763,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 +828,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(); } }
@@ -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);
 	}
 }
@@ -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()
 	{
@@ -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());
 			}
 		}
 	}
 }
@@ -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)) {
@@ -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)
 	{
@@ -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();
 	}
@@ -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);
 	}
@@ -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();
 	}
@@ -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)
 	{
@@ -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);}
 }
@@ -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()); }
 }
@@ -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
@@ -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);}
 }
@@ -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); }
@@ -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;
 	}
 }
@@ -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();
@@ -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;
 		}
 	}
 }
@@ -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; }		
 }
@@ -0,0 +1,11 @@
 package speiger.src.collections.tests;
@SuppressWarnings("javadoc")
 public enum OrderedMapTests
 {
 	PUT_MOVE,
 	MOVE,
 	GET_MOVE,
 	FIRST,
 	LAST;
 }
@@ -0,0 +1,10 @@
 package speiger.src.collections.tests;
@SuppressWarnings("javadoc")
 public enum OrderedSetTest
 {
 	ADD_MOVE,
 	MOVE,
 	PEEK,
 	POLL;
 }
@@ -3,9 +3,6 @@ package speiger.src.collections.tests;
@SuppressWarnings("javadoc")
 public enum SortedMapTests
 {
 	PUT_MOVE,
 	MOVE,
 	GET_MOVE,
 	FIRST,
 	LAST,
 	SUB_MAP,
@@ -3,8 +3,6 @@ package speiger.src.collections.tests;
@SuppressWarnings("javadoc")
 public enum SortedSetTest
 {
 	ADD_MOVE,
 	MOVE,
 	PEEK,
 	POLL,
 	SUB_SET,
Author	SHA1	Message	Date
Speiger	8f32b2d887	Merge remote-tracking branch 'Github/master'	2021-12-25 03:49:45 +01:00
Speiger	e6c9600b40	Refactoring and Deprecating SortedMap/Sets - Added: OrderedMap/Set - Added: All Relevant functions into Ordered interface - Changed: Marked all Relevant SortedMap/Set functions Deprecated until 0.6.0 - Fixed: All code that was relevant to this	2021-12-25 03:46:51 +01:00
SpeigerandGitHub	d5f2acb9ab	Update LICENSE	2021-12-19 21:19:28 +01:00
Speiger	3274e96355	Added Benchmark links	2021-12-16 14:03:39 +01:00
Speiger	78dfa286b0	New Version - Fixed: Bugs with Queues starting with the wrong size - Fixed: ArrayGrowth for Queues was +1 instead of +50% - Added: Benchmarks with java and FastUtil	2021-12-16 13:46:55 +01:00
Speiger	f32624d131	Build Release.. -Fixed: Doc error on gradle build. -Fixed: SubSet.iterator had a ambiguity.	2021-12-14 09:05:25 +01:00
Speiger	59a417056c	Added Missing method & fixed potential issue with TreeSetBiIterators	2021-12-13 13:56:28 +01:00
Speiger	18f6704ed7	Expanded Unit tests to IntLists/Sets Maps are sadly not possible. It will require writing templates for permutations effectively copying guavas Test library. So this will take a lot longer	2021-12-13 13:45:35 +01:00
Speiger	caf2f22e9f	Finished the Basic Unit test frame work to ensure stablity. -Added: 150k Unit tests. -Fixed: Reworked the NavigableSet/Map implementations of RBTree/AVLTree/Array Sets/Maps	2021-12-13 10:41:20 +01:00