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
Added Benchmark links
2021-12-25 03:46:51 +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 · 2021-12-13 13:56:28 +01:00 · 2021-12-13 13:45:35 +01:00
52 changed files with 5881 additions and 4688 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.
@@ -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	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
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