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

Changelog.md

@@ -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.

README.md

@@ -6,11 +6,11 @@ But its focus is a different one.
 
 ## Main Features:      
 - ArrayLists / LinkedLists
-- HashSet/Map (Linked & HashControl)
-- TreeSet/Map (RB & AVL)
-- EnumMap
+- HashSets/Maps (Linked & HashControl)
+- TreeSets/Maps (RB & AVL)
+- 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.     
-So it is not advised to use them until these issues are addressed.     
-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     
+### Benchmarks
+Benchmarks can be found here: [Click Me](https://github.com/Speiger/Primitive-Collections-Benchmarks/tree/master)
 
 ## Specialized Functions
 New Specialized functions that were added to increase performance or reduce allocations or Quality Of life.
@@ -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.

build.gradle

@@ -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) {

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

@@ -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");

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

@@ -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, "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "NavigableMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
+		addBlockage(ClassType.BOOLEAN, "ArraySet", "AVLTreeSet", "RBTreeSet", "SortedSet", "OrderedSet", "NavigableSet", "OpenHashSet", "OpenCustomHashSet", "LinkedOpenHashSet", "LinkedOpenCustomHashSet");
+		addBlockage(ClassType.BOOLEAN, "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "OrderedMap", "NavigableMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
 	}
 	
 	protected void create(ClassType mainType, ClassType subType) 

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

@@ -232,6 +232,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	 * @param index the index where to append the elements to
 	 * @param c the elements to append to the list
 	 * @throws IndexOutOfBoundsException if index is outside of the lists range
+	 * @throws NullPointerException if collection contains a null element
 	 */
 	@Override
 	@Primitive
@@ -239,6 +240,9 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		if(c instanceof COLLECTION) return addAll(index, (COLLECTION KEY_GENERIC_TYPE)c);
 		int add = c.size();
 		if(add <= 0) return false;
+#if !TYPE_OBJECT
+		if(c.contains(null)) throw new NullPointerException();
+#endif
 		grow(size + add);
 		if(index != size) System.arraycopy(data, index, data, index+add, size - index);
 		size+=add;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -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;
-		last = ++last % array.length;
+		array[last++] = e;
+		if(last == array.length) last = 0;
 		if(last == first) expand();
 	}
 	

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

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

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

@@ -19,6 +19,7 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
+import speiger.src.collections.utils.SanityChecks;
 
 /**
  * A Simple Heap base Priority Queue implementation
@@ -66,7 +67,6 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 	 */
 	public HEAP_PRIORITY_QUEUE(int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
 		if(size > 0) array = NEW_KEY_ARRAY(size);
-		this.size = size;
 		comparator = comp;
 	}
 	
@@ -207,7 +207,7 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 	
 	@Override
 	public void enqueue(KEY_TYPE e) {
-		if(size == array.length) array = Arrays.copyOf(array, size + 1);
+		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (array.length >> 1), SanityChecks.MAX_ARRAY_SIZE), size+1));
 		array[size++] = e;
 		ARRAYS.shiftUp(array, size-1, comparator);
 	}

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

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

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

@@ -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;

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

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

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

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

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

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

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

@@ -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;

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

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

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

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

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

@@ -18,6 +18,7 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.sets.SORTED_SET;
 import speiger.src.collections.PACKAGE.utils.COLLECTIONS.EmptyCollection;
 import speiger.src.collections.PACKAGE.utils.COLLECTIONS.SynchronizedCollection;
@@ -95,6 +96,29 @@ public class SETS
 		return s instanceof SynchronizedSortedSet ? s : (s instanceof ITrimmable ? new SynchronizedSortedTrimSetBRACES(s, mutex) : new SynchronizedSortedSetBRACES(s, mutex));
 	}
 	
+	/**
+	 * Creates a Synchronized OrderedSet while preserving the ITrimmable interface
+	 * @param s the set that should be synchronized
+	 * @Type(T)
+	 * @return a OrderedSet that is synchronized
+	 * @note if the set is already synchronized then it will just self return it
+	 */
+	public static GENERIC_KEY_BRACES ORDERED_SET KEY_GENERIC_TYPE synchronize(ORDERED_SET KEY_GENERIC_TYPE s) {
+		return s instanceof SynchronizedOrderedSet ? s : (s instanceof ITrimmable ? new SynchronizedOrderedTrimSetBRACES(s) : new SynchronizedOrderedSetBRACES(s));
+	}
+	
+	/**
+	 * Creates a Synchronized OrderedSet while preserving the ITrimmable interface
+	 * @param s the set that should be synchronized
+	 * @param mutex controller for access
+	 * @Type(T)
+	 * @return a OrderedSet that is synchronized
+	 * @note if the set is already synchronized then it will just self return it
+	 */
+	public static GENERIC_KEY_BRACES ORDERED_SET KEY_GENERIC_TYPE synchronize(ORDERED_SET KEY_GENERIC_TYPE s, Object mutex) {
+		return s instanceof SynchronizedOrderedSet ? s : (s instanceof ITrimmable ? new SynchronizedOrderedTrimSetBRACES(s, mutex) : new SynchronizedOrderedSetBRACES(s, mutex));
+	}
+	
 	/**
 	 * Creates a Synchronized NavigableSet while preserving the ITrimmable interface
 	 * @param s the set that should be synchronized
@@ -138,6 +162,16 @@ public class SETS
 		return s instanceof UnmodifiableSortedSet ? s : new UnmodifiableSortedSetBRACES(s);
 	}
 	
+	/**
+	 * Creates Unmodifyable OrderedSet wrapper
+	 * @param s OrderedSet that should be made unmodifiable
+	 * @Type(T)
+	 * @return a UnmodifyableOrderedSet, if the set is already unmodifiable then it returns itself
+	 */
+	public static GENERIC_KEY_BRACES ORDERED_SET KEY_GENERIC_TYPE unmodifiable(ORDERED_SET KEY_GENERIC_TYPE s) {
+		return s instanceof UnmodifiableOrderedSet ? s : new UnmodifiableOrderedSetBRACES(s);
+	}
+	
 	/**
 	 * Creates Unmodifyable NavigableSet wrapper
 	 * @param s navigableSet that should be made unmodifiable
@@ -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(); } }
 	}

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

@@ -32,6 +32,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 #if !TYPE_BOOLEAN
 import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.sets.SET;
@@ -161,6 +162,28 @@ public class MAPS
 	 */
 	public static GENERIC_KEY_VALUE_BRACES SORTED_MAP KEY_VALUE_GENERIC_TYPE synchronize(SORTED_MAP KEY_VALUE_GENERIC_TYPE map, Object mutex) { return map instanceof SynchronizedSortedMap ? map : new SynchronizedSortedMapKV_BRACES(map, mutex); }
 	
+	/**
+	 * Helper function that creates a Helper wrapper to synchronize access into the OrderedMap.
+	 * @param map the OrderedMap that should be synchronized
+	 * @Type(T)
+	 * @ValueType(V)
+	 * @return a synchronized OrderedMap
+	 * @note if the inputted map is already synchronized then it will just return it instead
+	 * @note iterators do not support synchronization
+	 */
+	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof SynchronizedOrderedMap ? map : new SynchronizedOrderedMapKV_BRACES(map); }
+	/**
+	 * Helper function that creates a Helper wrapper to synchronize access with custom access control into the OrderedMap.
+	 * @param map the OrderedMap that should be synchronized
+	 * @param mutex the object that controls access
+	 * @Type(T)
+	 * @ValueType(V)
+	 * @return a synchronized OrderedMap
+	 * @note if the inputted map is already synchronized then it will just return it instead
+	 * @note iterators do not support synchronization
+	 */
+	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map, Object mutex) { return map instanceof SynchronizedOrderedMap ? map : new SynchronizedOrderedMapKV_BRACES(map, mutex); }
+	
 	/**
 	 * Helper function that creates a Helper wrapper to synchronize access into the NavigableMap.
 	 * @param map the NavigableMap that should be synchronized
@@ -192,6 +215,17 @@ public class MAPS
 	 * @note if the inputted map is already unmodifiable then it will just return it instead
 	 */
 	public static GENERIC_KEY_VALUE_BRACES MAP KEY_VALUE_GENERIC_TYPE unmodifiable(MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof UnmodifyableMap ? map : new UnmodifyableMapKV_BRACES(map); }
+	
+	/**
+	 * A Helper function that creates a Helper wrapper to only allow Read Access into the OrderedMap
+	 * @param map the OrderedMap that should be made Unmodifiable
+	 * @Type(T)
+	 * @ValueType(V)
+	 * @return a unmodifiable OrderedMap
+	 * @note if the inputted OrderedMap is already unmodifiable then it will just return it instead
+	 */
+	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof UnmodifyableOrderedMap ? map : new UnmodifyableOrderedMapKV_BRACES(map); }
+	
 	/**
 	 * A Helper function that creates a Helper wrapper to only allow Read Access into the SortedMap
 	 * @param map the SortedMap that should be made Unmodifiable
@@ -201,6 +235,7 @@ public class MAPS
 	 * @note if the inputted SortedMap is already unmodifiable then it will just return it instead
 	 */
 	public static GENERIC_KEY_VALUE_BRACES SORTED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable(SORTED_MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof UnmodifyableSortedMap ? map : new UnmodifyableSortedMapKV_BRACES(map); }
+	
 	/**
 	 * A Helper function that creates a Helper wrapper to only allow Read Access into NavigableMap Map
 	 * @param map the NavigableMap that should be made Unmodifiable
@@ -210,6 +245,7 @@ public class MAPS
 	 * @note if the inputted NavigableMap is already unmodifiable then it will just return it instead
 	 */
 	public static GENERIC_KEY_VALUE_BRACES NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE unmodifiable(NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE map) { return map instanceof UnmodifyableNavigableMap ? map : new UnmodifyableNavigableMapKV_BRACES(map); }
+	
 	/**
 	 * A Helper function that creates a Unmodifyable Entry
 	 * @param entry the Entry that should be made unmodifiable
@@ -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 {
-		SORTED_MAP KEY_VALUE_GENERIC_TYPE map;
+	public static class UnmodifyableOrderedMap KEY_VALUE_GENERIC_TYPE extends UnmodifyableMap KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE {
+		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(); } }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,26 +1,20 @@
 package speiger.src.collections.ints.maps;
 
-import java.util.EnumSet;
-
-import speiger.src.collections.ints.base.BaseInt2IntSortedMapTest;
+import speiger.src.collections.ints.base.BaseInt2IntOrderedMapTest;
 import speiger.src.collections.ints.maps.impl.customHash.Int2IntLinkedOpenCustomHashMap;
-import speiger.src.collections.ints.maps.interfaces.Int2IntSortedMap;
-import speiger.src.collections.tests.SortedMapTests;
+import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap;
 
 @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)); }
-	
-	@Override
-	public Int2IntSortedMap createMap(int[] keys, int[] values)
+	public Int2IntOrderedMap createMap(int[] keys, int[] values)
 	{
 		return new Int2IntLinkedOpenCustomHashMap(keys, values, STRATEGY);
 	}
 	
 	@Override
-	public Int2IntSortedMap createEmptyMap()
+	public Int2IntOrderedMap createEmptyMap()
 	{
 		return new Int2IntLinkedOpenCustomHashMap(STRATEGY);
 	}

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

@@ -1,26 +1,20 @@
 package speiger.src.collections.ints.maps;
 
-import java.util.EnumSet;
-
-import speiger.src.collections.ints.base.BaseInt2IntSortedMapTest;
+import speiger.src.collections.ints.base.BaseInt2IntOrderedMapTest;
 import speiger.src.collections.ints.maps.impl.hash.Int2IntLinkedOpenHashMap;
-import speiger.src.collections.ints.maps.interfaces.Int2IntSortedMap;
-import speiger.src.collections.tests.SortedMapTests;
+import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap;
 
 @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)); }
-	
-	@Override
-	public Int2IntSortedMap createMap(int[] keys, int[] values)
+	public Int2IntOrderedMap createMap(int[] keys, int[] values)
 	{
 		return new Int2IntLinkedOpenHashMap(keys, values);
 	}
 	
 	@Override
-	public Int2IntSortedMap createEmptyMap()
+	public Int2IntOrderedMap createEmptyMap()
 	{
 		return new Int2IntLinkedOpenHashMap();
 	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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