New Tests & BugFixes

-Added: Tests for the Copying of Collections.
-Fixed: PriorityQueues didn't have hashCode/equals/toString implemented

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

@@ -184,6 +184,7 @@ public class GlobalVariables
 		
 		//Abstract Classes
 		addAbstractMapper("ABSTRACT_COLLECTION", "Abstract%sCollection");
+		addAbstractMapper("ABSTRACT_PRIORITY_QUEUE", "Abstract%sPriorityQueue");
 		addAbstractMapper("ABSTRACT_SET", "Abstract%sSet");
 		addAbstractMapper("ABSTRACT_LIST", "Abstract%sList");
 		addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");

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

@@ -78,6 +78,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		nameRemapper.put("IArray", "I%sArray");
 		nameRemapper.put("AbstractMap", "Abstract%sMap");
 		nameRemapper.put("AbstractCollection", "Abstract%sCollection");
+		nameRemapper.put("AbstractPriorityQueue", "Abstract%sPriorityQueue");
 		nameRemapper.put("AbstractSet", "Abstract%sSet");
 		nameRemapper.put("AbstractList", "Abstract%sList");
 		nameRemapper.put("EnumMap", "Enum2%sMap");

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

@@ -35,6 +35,9 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 		return modified;
 	}
 	
+	@Override
+	public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+	
 #if !TYPE_OBJECT
 	/** {@inheritDoc}
 	 * <p>This default implementation delegates to the corresponding type-specific function.

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

@@ -123,6 +123,15 @@ public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITE
  	 */
 	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c);
 	
+	/**
+	 * A Function that does a shallow clone of the Collection itself.
+	 * This function is more optimized then a copy constructor since the Collection does not have to be unsorted/resorted.
+	 * It can be compared to Cloneable but with less exception risk
+	 * @return a Shallow Copy of the collection
+	 * @note Wrappers and view collections will not support this feature
+	 */
+	public COLLECTION KEY_GENERIC_TYPE copy();
+	
 #if !TYPE_OBJECT
 	/**
 	 * A Type-Specific toArray function that delegates to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.

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

@@ -229,6 +229,8 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		while(size < size()) REMOVE(size() - 1);
 	}
 	
+	public ABSTRACT_LIST KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+	
 	private class SUB_LIST extends ABSTRACT_LIST KEY_GENERIC_TYPE {
 		ABSTRACT_LIST KEY_GENERIC_TYPE l;
 		int offset;

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

@@ -1015,6 +1015,14 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		grow(size);
 	}
 	
+	@Override
+	public ARRAY_LIST KEY_GENERIC_TYPE copy() {
+		ARRAY_LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		list.data = Arrays.copyOf(data, data.length);
+		list.size = size;
+		return list;
+	}
+	
 	protected void grow(int capacity) {
 		if(capacity < data.length) return;
 		data = Arrays.copyOf(data, data == ARRAYS.EMPTY_ARRAY ? Math.max(DEFAULT_ARRAY_SIZE, capacity) : (int)Math.max(Math.min((long)data.length + (data.length >> 1), SanityChecks.MAX_ARRAY_SIZE), capacity));		

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

@@ -261,6 +261,11 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 		return data[index];
 	}
 	
+	@Override
+	public IMMUTABLE_LIST KEY_GENERIC_TYPE copy() {
+		return new IMMUTABLE_LISTBRACES(Arrays.copyOf(data, data.length));
+	}
+	
 	/**
 	 * A Type Specific foreach function that reduces (un)boxing
 	 * 

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

@@ -820,6 +820,23 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		size = 0;
 	}
 	
+	@Override
+	public LINKED_LIST KEY_GENERIC_TYPE copy() {
+		LINKED_LIST KEY_GENERIC_TYPE list = new LINKED_LISTBRACES();
+		list.size = size;
+		if(first != null) {
+			list.first = new EntryBRACES(first.value, null, null);
+			Entry KEY_GENERIC_TYPE lastReturned = list.first;
+			for(Entry KEY_GENERIC_TYPE entry = first.next;entry != null;entry = entry.next) {
+				Entry KEY_GENERIC_TYPE next = new EntryBRACES(entry.value, lastReturned, null);
+				lastReturned.next = next;
+				lastReturned = next;
+			}
+			list.last = lastReturned;
+		}
+		return list;
+	}
+	
 	protected Entry KEY_GENERIC_TYPE getNode(int index) {
 		if(index < size >> 2) {
 			Entry KEY_GENERIC_TYPE x = first;

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

@@ -339,6 +339,8 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
 	 */
 	public void size(int size);
 	
+	@Override
+	public LIST KEY_GENERIC_TYPE copy();
 #if !TYPE_OBJECT
 	
 	/** {@inheritDoc}

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

@@ -47,6 +47,11 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 		return this;
 	}
 	
+	@Override
+	public MAP KEY_VALUE_GENERIC_TYPE copy() { 
+		 throw new UnsupportedOperationException();
+	}
+	
 #if !TYPE_OBJECT || !VALUE_OBJECT
 	@Override
 	@Deprecated

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

@@ -1,5 +1,6 @@
 package speiger.src.collections.PACKAGE.maps.impl.customHash;
 
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
@@ -336,6 +337,23 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		return values[index];
 	}
 	
+	@Override
+	public LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE map = new LINKED_CUSTOM_HASH_MAPKV_BRACES(0, loadFactor, strategy);
+		map.minCapacity = minCapacity;
+		map.mask = mask;
+		map.maxFill = maxFill;
+		map.nullIndex = nullIndex;
+		map.containsNull = containsNull;
+		map.size = size;
+		map.keys = Arrays.copyOf(keys, keys.length);
+		map.values = Arrays.copyOf(values, values.length);
+		map.links = Arrays.copyOf(links, links.length);
+		map.firstIndex = firstIndex;
+		map.lastIndex = lastIndex;
+		return map;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() {
 		return null;
@@ -653,6 +671,9 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			return new FastEntryIterator(fromElement);
 		}
 		
+		@Override
+		public MapEntrySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(Consumer<? super MAP.Entry KEY_VALUE_GENERIC_TYPE> action) {
 			int index = firstIndex;
@@ -861,6 +882,9 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			return new KeyIterator(fromElement);
 		}
 		
+		@Override
+		public KeySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public int size() {
 			return LINKED_CUSTOM_HASH_MAP.this.size();

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

@@ -423,6 +423,20 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	}
 	
 #endif
+	@Override
+	public CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE map = new CUSTOM_HASH_MAPKV_BRACES(0, loadFactor, strategy);
+		map.minCapacity = minCapacity;
+		map.mask = mask;
+		map.maxFill = maxFill;
+		map.nullIndex = nullIndex;
+		map.containsNull = containsNull;
+		map.size = size;
+		map.keys = Arrays.copyOf(keys, keys.length);
+		map.values = Arrays.copyOf(values, values.length);
+		return map;
+	}
+	
 	@Override
 	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
@@ -964,6 +978,9 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			return new KeyIterator();
 		}
 		
+		@Override
+		public KeySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public int size() {
 			return CUSTOM_HASH_MAP.this.size();

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

@@ -1,5 +1,6 @@
 package speiger.src.collections.PACKAGE.maps.impl.hash;
 
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
@@ -313,6 +314,23 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		return values[index];
 	}
 	
+	@Override
+	public LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE map = new LINKED_HASH_MAPKV_BRACES(0, loadFactor);
+		map.minCapacity = minCapacity;
+		map.mask = mask;
+		map.maxFill = maxFill;
+		map.nullIndex = nullIndex;
+		map.containsNull = containsNull;
+		map.size = size;
+		map.keys = Arrays.copyOf(keys, keys.length);
+		map.values = Arrays.copyOf(values, values.length);
+		map.links = Arrays.copyOf(links, links.length);
+		map.firstIndex = firstIndex;
+		map.lastIndex = lastIndex;
+		return map;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() {
 		return null;
@@ -630,6 +648,9 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			return new FastEntryIterator(fromElement);
 		}
 		
+		@Override
+		public MapEntrySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(Consumer<? super MAP.Entry KEY_VALUE_GENERIC_TYPE> action) {
 			int index = firstIndex;
@@ -838,6 +859,9 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			return new KeyIterator(fromElement);
 		}
 		
+		@Override
+		public KeySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public int size() {
 			return LINKED_HASH_MAP.this.size();

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

@@ -384,6 +384,20 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	}
 	
 #endif
+	@Override
+	public HASH_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		HASH_MAP KEY_VALUE_GENERIC_TYPE map = new HASH_MAPKV_BRACES(0, loadFactor);
+		map.minCapacity = minCapacity;
+		map.mask = mask;
+		map.maxFill = maxFill;
+		map.nullIndex = nullIndex;
+		map.containsNull = containsNull;
+		map.size = size;
+		map.keys = Arrays.copyOf(keys, keys.length);
+		map.values = Arrays.copyOf(values, values.length);
+		return map;
+	}
+	
 	@Override
 	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new MapEntrySet();
@@ -934,6 +948,9 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			HASH_MAP.this.clear();
 		}
 		
+		@Override
+		public KeySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
 			if(containsNull) action.accept(keys[nullIndex]);

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

@@ -1,7 +1,8 @@
 package speiger.src.collections.PACKAGE.maps.impl.immutable;
 
-import java.util.Map;
+import java.util.Arrays;
 import java.util.Comparator;
+import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.function.Consumer;
@@ -103,6 +104,10 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	/** Amount of Elements stored in the HashMap */
 	protected int size;
 	
+	/**
+	 * Helper constructor for copying the Map
+	 */
+	protected IMMUTABLE_HASH_MAP() {}
 	
 #if !TYPE_OBJECT || !VALUE_OBJECT
 	/**
@@ -412,6 +417,21 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		return valuesC;
 	}
 	
+	@Override
+	public IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE map = new IMMUTABLE_HASH_MAPKV_BRACES();
+		map.mask = mask;
+		map.nullIndex = nullIndex;
+		map.containsNull = containsNull;
+		map.size = size;
+		map.keys = Arrays.copyOf(keys, keys.length);
+		map.values = Arrays.copyOf(values, values.length);
+		map.links = Arrays.copyOf(links, links.length);
+		map.firstIndex = firstIndex;
+		map.lastIndex = lastIndex;
+		return map;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
 	@Override
@@ -589,6 +609,9 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			return new FastEntryIterator(fromElement);
 		}
 		
+		@Override
+		public MapEntrySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(Consumer<? super MAP.Entry KEY_VALUE_GENERIC_TYPE> action) {
 			int index = firstIndex;
@@ -773,6 +796,9 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			return new KeyIterator(fromElement);
 		}
 		
+		@Override
+		public KeySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public int size() {
 			return IMMUTABLE_HASH_MAP.this.size();

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

@@ -554,6 +554,14 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		size = 0;
 	}
 	
+	public ARRAY_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		ARRAY_MAP KEY_VALUE_GENERIC_TYPE map = new ARRAY_MAPKV_BRACES();
+		map.size = size;
+		map.keys = Arrays.copyOf(keys, keys.length);
+		map.values = Arrays.copyOf(values, keys.length);
+		return map;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() {
 		return null;
@@ -981,6 +989,11 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			return entrySet;
 		}
 		
+		@Override
+		public SubMap copy() { 
+			throw new UnsupportedOperationException(); 
+		}
+		
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() {
 			return null;
@@ -1133,6 +1146,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				return new SubFastEntryIterator(fromElement);
 			}
 			
+			@Override
+			public SubMapEntrySet copy() { throw new UnsupportedOperationException(); }
+			
 			@Override
 			public void forEach(Consumer<? super MAP.Entry KEY_VALUE_GENERIC_TYPE> action) {
 				Objects.requireNonNull(action);
@@ -1316,6 +1332,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			@Override
 			public KEY_TYPE POLL_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); }
 			
+			@Override
+			public SubKeySet copy() { throw new UnsupportedOperationException(); }
+			
 			@Override
 			public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) { 
 				Objects.requireNonNull(action);
@@ -1698,6 +1717,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			return new FastEntryIterator(fromElement);
 		}
 		
+		@Override
+		public MapEntrySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(Consumer<? super MAP.Entry KEY_VALUE_GENERIC_TYPE> action) {
 			Objects.requireNonNull(action);
@@ -1882,6 +1904,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Override
 		public KEY_TYPE POLL_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); }
 		
+		@Override
+		public KeySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) { 
 			Objects.requireNonNull(action);

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

@@ -176,6 +176,15 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 	}
 	
 #endif
+	@Override
+	public ENUM_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		ENUM_MAP KEY_VALUE_GENERIC_TYPE map = new ENUM_MAPKV_BRACES(keyType);
+		map.size = size;
+		System.arraycopy(present, 0, map.present, 0, Math.min(present.length, map.present.length));
+		System.arraycopy(values, 0, map.values, 0, Math.min(values.length, map.values.length));
+		return map;
+	}
+	
 	@Override
 	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
 		if(entrySet == null) entrySet = new EntrySet();

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

@@ -127,6 +127,18 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		return values[index];
 	}
 	
+	@Override
+	public LINKED_ENUM_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		LINKED_ENUM_MAP KEY_VALUE_GENERIC_TYPE map = new LINKED_ENUM_MAPKV_BRACES(keyType);
+		map.size = size;
+		System.arraycopy(present, 0, map.present, 0, Math.min(present.length, map.present.length));
+		System.arraycopy(values, 0, map.values, 0, Math.min(values.length, map.values.length));
+		System.arraycopy(links, 0, map.links, 0, Math.min(links.length, map.links.length));
+		map.firstIndex = firstIndex;
+		map.lastIndex = lastIndex;
+		return map;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() {
 		return null;
@@ -351,6 +363,8 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 			return new FastEntryIterator(fromElement);
 		}
 		
+		public MapEntrySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(Consumer<? super MAP.Entry KEY_VALUE_GENERIC_TYPE> action) {
 			int index = firstIndex;
@@ -477,6 +491,8 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 			return new KeyIterator(fromElement);
 		}
 		
+		public KeySet copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public int size() {
 			return LINKED_ENUM_MAP.this.size();

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

@@ -610,6 +610,21 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		return new KeyIterator(findNode(key));
 	}
 	
+	public AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE set = new AVL_TREE_MAPKV_BRACES();
+		set.size = size;
+		if(tree != null) {
+			set.tree = tree.copy();
+			Entry KEY_VALUE_GENERIC_TYPE lastFound = null;
+			for(Entry KEY_VALUE_GENERIC_TYPE entry = tree;entry != null;entry = entry.left) lastFound = entry;
+			set.first = lastFound;
+			lastFound = null;
+			for(Entry KEY_VALUE_GENERIC_TYPE entry = tree;entry != null;entry = entry.right) lastFound = entry;
+			set.last = lastFound;
+		}
+		return set;
+	}
+	
 	@Override
 	public SORTED_SET KEY_GENERIC_TYPE keySet() {
 		return navigableKeySet();
@@ -1133,7 +1148,8 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		abstract AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE next(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry);
 		abstract AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE previous(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry);
 		
-		
+		@Override
+		public NavigableSubMap KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 		@Override
 		public abstract NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap();
 		@Override
@@ -1952,6 +1968,9 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		}
 		
 #endif
+		@Override
+		public KeySet KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) {
 			return new KeySetKV_BRACES(m.subMap(fromElement, fromInclusive, toElement, toInclusive));
@@ -2320,6 +2339,22 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			this.parent = parent;
 		}
 		
+		Entry KEY_VALUE_GENERIC_TYPE copy() {
+			Entry KEY_VALUE_GENERIC_TYPE entry = new EntryKV_BRACES(key, value, null);
+			entry.state = state;
+			if(left != null) {
+				Entry KEY_VALUE_GENERIC_TYPE newLeft = left.copy();
+				entry.left = newLeft;
+				newLeft.parent = entry;
+			}
+			if(right != null) {
+				Entry KEY_VALUE_GENERIC_TYPE newRight = right.copy();
+				entry.right = newRight;
+				newRight.parent = entry;
+			}
+			return entry;
+		}
+		
 		@Override
 		public KEY_TYPE ENTRY_KEY() {
 			return key;

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

@@ -609,6 +609,21 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		return new KeyIterator(findNode(key));
 	}
 	
+	public RB_TREE_MAP KEY_VALUE_GENERIC_TYPE copy() {
+		RB_TREE_MAP KEY_VALUE_GENERIC_TYPE set = new RB_TREE_MAPKV_BRACES();
+		set.size = size;
+		if(tree != null) {
+			set.tree = tree.copy();
+			Entry KEY_VALUE_GENERIC_TYPE lastFound = null;
+			for(Entry KEY_VALUE_GENERIC_TYPE entry = tree;entry != null;entry = entry.left) lastFound = entry;
+			set.first = lastFound;
+			lastFound = null;
+			for(Entry KEY_VALUE_GENERIC_TYPE entry = tree;entry != null;entry = entry.right) lastFound = entry;
+			set.last = lastFound;
+		}
+		return set;
+	}
+	
 	@Override
 	public SORTED_SET KEY_GENERIC_TYPE keySet() {
 		return navigableKeySet();
@@ -1187,6 +1202,8 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		abstract RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE next(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry);
 		abstract RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE previous(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry);
 		
+		@Override
+		public NavigableSubMap KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 		@Override
 		public abstract NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap();
 		@Override
@@ -2018,6 +2035,9 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		}
 		
 #endif
+		@Override
+		public KeySet KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) {
 			return new KeySetKV_BRACES(m.subMap(fromElement, fromInclusive, toElement, toInclusive));
@@ -2388,6 +2408,22 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			this.parent = parent;
 		}
 		
+		Entry KEY_VALUE_GENERIC_TYPE copy() {
+			Entry KEY_VALUE_GENERIC_TYPE entry = new EntryKV_BRACES(key, value, null);
+			entry.state = state;
+			if(left != null) {
+				Entry KEY_VALUE_GENERIC_TYPE newLeft = left.copy();
+				entry.left = newLeft;
+				newLeft.parent = entry;
+			}
+			if(right != null) {
+				Entry KEY_VALUE_GENERIC_TYPE newRight = right.copy();
+				entry.right = newRight;
+				newRight.parent = entry;
+			}
+			return entry;
+		}
+		
 		@Override
 		public KEY_TYPE ENTRY_KEY() {
 			return key;

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

@@ -59,6 +59,15 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 	 */
 	public MAP KEY_VALUE_GENERIC_TYPE setDefaultReturnValue(VALUE_TYPE v);
 	
+	/**
+	 * A Function that does a shallow clone of the Map itself.
+	 * This function is more optimized then a copy constructor since the Map does not have to be unsorted/resorted.
+	 * It can be compared to Cloneable but with less exception risk
+	 * @return a Shallow Copy of the Map
+	 * @note Wrappers and view Maps will not support this feature
+	 */
+	public MAP KEY_VALUE_GENERIC_TYPE copy();
+	
 	/**
 	 * Type Specific method to reduce boxing/unboxing of values
 	 * @param key the key that should be inserted,

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

@@ -10,6 +10,8 @@ import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
  */
 public interface NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE extends SORTED_MAP KEY_VALUE_GENERIC_TYPE, NavigableMap<CLASS_TYPE, CLASS_VALUE_TYPE>
 {
+	@Override
+	public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE copy();
 	/** @return a Type Specific desendingMap */
 	@Override
 	public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap();

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

@@ -75,6 +75,9 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator();
 	
+	@Override
+	public SORTED_MAP KEY_VALUE_GENERIC_TYPE copy();
+	
 	@Override
 	public SET KEY_GENERIC_TYPE keySet();
 	@Override

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

@@ -0,0 +1,46 @@
+package speiger.src.collections.PACKAGE.queues;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+#endif
+import java.util.StringJoiner;
+
+/**
+ * Helper class that implements all the essential methods for the PriorityQueues
+ * @Type(T)
+ */
+public abstract class ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_QUEUE KEY_GENERIC_TYPE
+{
+	@Override
+	public boolean equals(Object obj) {
+		if(obj instanceof PRIORITY_QUEUE) {
+			PRIORITY_QUEUE KEY_GENERIC_TYPE queue = (PRIORITY_QUEUE KEY_GENERIC_TYPE)obj;
+			if(queue.size() != size()) return false;
+			for(int i = 0,m=size();i<m;i++) {
+				if(KEY_EQUALS_NOT(queue.peek(i), peek(i))) return false;
+			}
+			return true;
+		}
+		return false;
+	}
+	
+	@Override
+	public int hashCode() {
+        int result = 1;
+        for (int i = 0,m=size();i<m;i++) {
+            result = 31 * result + KEY_TO_HASH(peek(i));
+        }
+		return result;
+	}
+	
+	@Override
+	public String toString()
+	{
+		if(isEmpty()) return "[]";
+		StringJoiner joiner = new StringJoiner(", ", "[", "]");
+        for (int i = 0,m=size();i<m;i++) {
+        	joiner.add(KEY_TO_STRING(peek(i)));
+        }
+        return joiner.toString();
+	}
+}

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

@@ -1,7 +1,7 @@
 package speiger.src.collections.PACKAGE.queues;
 
-#if TYPE_OBJECT
 import java.util.Arrays;
+#if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
 #endif
@@ -22,7 +22,7 @@ import speiger.src.collections.utils.ITrimmable;
  * Its specific implementation uses a backing array that grows and shrinks as it is needed.
  * @Type(T)
  */
-public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE implements PRIORITY_DEQUEUE KEY_GENERIC_TYPE, ITrimmable
+public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_DEQUEUE KEY_GENERIC_TYPE, ITrimmable
 {
 	/** Max Possible ArraySize without the JVM Crashing */
 	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
@@ -222,6 +222,15 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE implements PRIORITY_DEQUEUE KEY_G
 	@Override
 	public void onChanged() {}
 	
+	@Override
+	public ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE copy() {
+		ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_FIFO_QUEUEBRACES();
+		queue.first = first;
+		queue.last = last;
+		queue.array = Arrays.copyOf(array, array.length);
+		return queue;
+	}
+	
 	@Override
 	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() { return null; }
 	

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

@@ -24,7 +24,7 @@ import speiger.src.collections.PACKAGE.utils.ARRAYS;
  * It is highly suggested to use HeapPriorityQueue otherwise, unless you know why you need this specific implementation
  * @Type(T)
  */
-public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_QUEUE KEY_GENERIC_TYPE
+public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE
 {
 	/** The Backing Array */
 	protected transient KEY_TYPE[] array = EMPTY_KEY_ARRAY;
@@ -322,6 +322,16 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_QUEUE KEY
 		return new Iter();
 	}
 	
+	@Override
+	public ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE copy() {
+		ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_PRIORITY_QUEUEBRACES();
+		queue.firstIndex = firstIndex;
+		queue.size = size;
+		queue.comparator = comparator;
+		queue.array = Arrays.copyOf(array, array.length);
+		return queue;
+	}
+	
 	@Override
 	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() {
 		return comparator;

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

@@ -23,7 +23,7 @@ import speiger.src.collections.PACKAGE.utils.ARRAYS;
  * It is a ArrayBased Alternative to TreeSets that has less object allocations
  * @Type(T)
  */
-public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_QUEUE KEY_GENERIC_TYPE
+public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE
 {
 	/** The Backing Array */
 	protected transient KEY_TYPE[] array = EMPTY_KEY_ARRAY;
@@ -319,6 +319,15 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_QUEUE KEY_
 		ARRAYS.shiftDown(array, size, 0, comparator);
 	}
 	
+	@Override
+	public HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE copy() {
+		HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new HEAP_PRIORITY_QUEUEBRACES();
+		queue.size = size;
+		queue.comparator = comparator;
+		queue.array = Arrays.copyOf(array, array.length);
+		return queue;
+	}
+	
 	@Override
 	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() {
 		return comparator;

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

@@ -22,4 +22,7 @@ public interface PRIORITY_DEQUEUE KEY_GENERIC_TYPE extends PRIORITY_QUEUE KEY_GE
 	 * @return the Last Element within the dequeue without deleting it
 	 */
 	public default KEY_TYPE last() { return peek(size()-1); }
+	
+	@Override
+	public PRIORITY_DEQUEUE KEY_GENERIC_TYPE copy();
 }

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

@@ -70,6 +70,15 @@ public interface PRIORITY_QUEUE KEY_GENERIC_TYPE extends ITERABLE KEY_GENERIC_TY
 	 */
 	public void onChanged();
 	
+	/**
+	 * A Function that does a shallow clone of the PriorityQueue itself.
+	 * This function is more optimized then a copy constructor since the PriorityQueue does not have to be unsorted/resorted.
+	 * It can be compared to Cloneable but with less exception risk
+	 * @return a Shallow Copy of the PriorityQueue
+	 * @note Wrappers and view PriorityQueues will not support this feature
+	 */
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE copy();
+	
 	/**
 	 * @return the sorter of the Queue, can be null
 	 */

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

@@ -538,6 +538,21 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		tree = null;
 	}
 	
+	public AVL_TREE_SET KEY_GENERIC_TYPE copy() {
+		AVL_TREE_SET KEY_GENERIC_TYPE set = new AVL_TREE_SETBRACES();
+		set.size = size;
+		if(tree != null) {
+			set.tree = tree.copy();
+			Entry KEY_GENERIC_TYPE lastFound = null;
+			for(Entry KEY_GENERIC_TYPE entry = tree;entry != null;entry = entry.left) lastFound = entry;
+			set.first = lastFound;
+			lastFound = null;
+			for(Entry KEY_GENERIC_TYPE entry = tree;entry != null;entry = entry.right) lastFound = entry;
+			set.last = lastFound;
+		}
+		return set;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }
 	
@@ -1009,6 +1024,9 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			return fromStart && toEnd ? set.size() : iterator().skip(Integer.MAX_VALUE);
 		}
 		
+		@Override
+		public SubSet KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
 			Objects.requireNonNull(action);
@@ -1250,6 +1268,22 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			this.parent = parent;
 		}
 		
+		Entry KEY_GENERIC_TYPE copy() {
+			Entry KEY_GENERIC_TYPE entry = new EntryBRACES(key, null);
+			entry.state = state;
+			if(left != null) {
+				Entry KEY_GENERIC_TYPE newLeft = left.copy();
+				entry.left = newLeft;
+				newLeft.parent = entry;
+			}
+			if(right != null) {
+				Entry KEY_GENERIC_TYPE newRight = right.copy();
+				entry.right = newRight;
+				newRight.parent = entry;
+			}
+			return entry;
+		}
+		
 		int getHeight() { return state; }
 		
 		void updateHeight() { state = (1 + Math.max(left == null ? -1 : left.getHeight(), right == null ? -1 : right.getHeight())); }

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

@@ -15,6 +15,8 @@ public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 {
 	@Override
 	public abstract ITERATOR KEY_GENERIC_TYPE iterator();
+	@Override
+	public ABSTRACT_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	
 	@Override
 	public int hashCode() {

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

@@ -450,6 +450,13 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return new SubSet(fromIndex, size - fromIndex);
 	}
 	
+	public ARRAY_SET KEY_GENERIC_TYPE copy() {
+		ARRAY_SET KEY_GENERIC_TYPE set = new ARRAY_SETBRACES();
+		set.data = Arrays.copyOf(data, data.length);
+		set.size = size;
+		return set;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() {
 		return null;
@@ -676,6 +683,9 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 			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);

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

@@ -4,6 +4,7 @@ package speiger.src.collections.PACKAGE.sets;
 import java.util.Comparator;
 import java.util.function.Consumer;
 #endif
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
@@ -50,6 +51,12 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	/** The Last Index in the Map */
 	protected int lastIndex = -1;
 	
+	/**
+	 * Helper constructor to optimize the copying
+	 * Only accessible through implementations
+	 */
+	protected IMMUTABLE_HASH_SET() {}
+	
 	/**
 	 * Helper constructor that allow to create a set from unboxed values
 	 * @param array the elements that should be put into the set
@@ -372,6 +379,20 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		return new SetIterator(fromElement);
 	}
 	
+	@Override
+	public IMMUTABLE_HASH_SET KEY_GENERIC_TYPE copy() {
+		IMMUTABLE_HASH_SET KEY_GENERIC_TYPE set = new IMMUTABLE_HASH_SETBRACES();
+		set.containsNull = containsNull;
+		set.firstIndex = firstIndex;
+		set.lastIndex = lastIndex;
+		set.size = size;
+		set.mask = mask;
+		set.nullIndex = nullIndex;
+		set.keys = Arrays.copyOf(keys, keys.length);
+		set.links = Arrays.copyOf(links, links.length);
+		return set;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
 	

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

@@ -4,6 +4,7 @@ package speiger.src.collections.PACKAGE.sets;
 import java.util.Comparator;
 import java.util.function.Consumer;
 #endif
+import java.util.Arrays;
 import java.util.Objects;
 import java.util.Collection;
 import java.util.Iterator;
@@ -609,6 +610,22 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		return new SetIterator(fromElement);
 	}
 	
+	@Override
+	public LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE copy() {
+		LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE set = new LINKED_CUSTOM_HASH_SETBRACES(0, loadFactor, strategy);
+		set.minCapacity = minCapacity;
+		set.mask = mask;
+		set.maxFill = maxFill;
+		set.nullIndex = nullIndex;
+		set.containsNull = containsNull;
+		set.size = size;
+		set.keys = Arrays.copyOf(keys, keys.length);
+		set.links = Arrays.copyOf(links, links.length);
+		set.firstIndex = firstIndex;
+		set.lastIndex = lastIndex;
+		return set;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
 	

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

@@ -3,6 +3,7 @@ package speiger.src.collections.PACKAGE.sets;
 #if TYPE_OBJECT
 import java.util.Comparator;
 #endif
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
@@ -580,6 +581,22 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		return new SetIterator(fromElement);
 	}
 	
+	@Override
+	public LINKED_HASH_SET KEY_GENERIC_TYPE copy() {
+		LINKED_HASH_SET KEY_GENERIC_TYPE set = new LINKED_HASH_SETBRACES(0, loadFactor);
+		set.minCapacity = minCapacity;
+		set.mask = mask;
+		set.maxFill = maxFill;
+		set.nullIndex = nullIndex;
+		set.containsNull = containsNull;
+		set.size = size;
+		set.keys = Arrays.copyOf(keys, keys.length);
+		set.links = Arrays.copyOf(links, links.length);
+		set.firstIndex = firstIndex;
+		set.lastIndex = lastIndex;
+		return set;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
 	

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

@@ -115,6 +115,8 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet<CLASS_TYPE>
 	/** @return a Type Specific desendingSet */
 	@Override
 	public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet();
+	@Override
+	public NAVIGABLE_SET KEY_GENERIC_TYPE copy();
 	
 	/**
 	 * A Type Specific Type Splititerator to reduce boxing/unboxing

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

@@ -445,6 +445,19 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 		return new SetIterator();
 	}
 	
+	@Override
+	public CUSTOM_HASH_SET KEY_GENERIC_TYPE copy() {
+		CUSTOM_HASH_SET KEY_GENERIC_TYPE set = new CUSTOM_HASH_SETBRACES(0, loadFactor, strategy);
+		set.minCapacity = minCapacity;
+		set.mask = mask;
+		set.maxFill = maxFill;
+		set.nullIndex = nullIndex;
+		set.containsNull = containsNull;
+		set.size = size;
+		set.keys = Arrays.copyOf(keys, keys.length);
+		return set;
+	}
+	
 	@Override
 	public void clear() {
 		if(size == 0) return;

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

@@ -477,6 +477,19 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 		return new SetIterator();
 	}
 	
+	@Override
+	public HASH_SET KEY_GENERIC_TYPE copy() {
+		HASH_SET KEY_GENERIC_TYPE set = new HASH_SETBRACES(0, loadFactor);
+		set.minCapacity = minCapacity;
+		set.mask = mask;
+		set.maxFill = maxFill;
+		set.nullIndex = nullIndex;
+		set.containsNull = containsNull;
+		set.size = size;
+		set.keys = Arrays.copyOf(keys, keys.length);
+		return set;
+	}
+	
 	@Override
 	public void clear() {
 		if(size == 0) return;

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

@@ -540,6 +540,21 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		tree = null;
 	}
 	
+	public RB_TREE_SET KEY_GENERIC_TYPE copy() {
+		RB_TREE_SET KEY_GENERIC_TYPE set = new RB_TREE_SETBRACES();
+		set.size = size;
+		if(tree != null) {
+			set.tree = tree.copy();
+			Entry KEY_GENERIC_TYPE lastFound = null;
+			for(Entry KEY_GENERIC_TYPE entry = tree;entry != null;entry = entry.left) lastFound = entry;
+			set.first = lastFound;
+			lastFound = null;
+			for(Entry KEY_GENERIC_TYPE entry = tree;entry != null;entry = entry.right) lastFound = entry;
+			set.last = lastFound;
+		}
+		return set;
+	}
+	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }
 	
@@ -1070,6 +1085,9 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			return fromStart && toEnd ? set.size() : iterator().skip(Integer.MAX_VALUE);
 		}
 		
+		@Override
+		public SubSet KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
 			Objects.requireNonNull(action);
@@ -1314,6 +1332,22 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			this.parent = parent;
 		}
 		
+		Entry KEY_GENERIC_TYPE copy() {
+			Entry KEY_GENERIC_TYPE entry = new EntryBRACES(key, null);
+			entry.state = state;
+			if(left != null) {
+				Entry KEY_GENERIC_TYPE newLeft = left.copy();
+				entry.left = newLeft;
+				newLeft.parent = entry;
+			}
+			if(right != null) {
+				Entry KEY_GENERIC_TYPE newRight = right.copy();
+				entry.right = newRight;
+				newRight.parent = entry;
+			}
+			return entry;
+		}
+		
 		boolean isBlack() {
 			return (state & BLACK) != 0;
 		}

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

@@ -16,6 +16,9 @@ public interface SET KEY_GENERIC_TYPE extends Set<CLASS_TYPE>, COLLECTION KEY_GE
 	@Override
 	public ITERATOR KEY_GENERIC_TYPE iterator();
 	
+	@Override
+	public SET KEY_GENERIC_TYPE copy();
+	
 #if !TYPE_OBJECT
 	/**
 	 * A Type Specific remove function to reduce boxing/unboxing

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

@@ -60,6 +60,9 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator();
 	
+	@Override
+	public SORTED_SET KEY_GENERIC_TYPE copy();
+	
 	@Override
 	public BI_ITERATOR KEY_GENERIC_TYPE iterator();
 	/**

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

@@ -128,6 +128,9 @@ public class COLLECTIONS
 			return c.iterator();
 		}
 		
+		@Override
+		public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		@Primitive
 		public boolean remove(Object o) { synchronized(mutex) { return c.remove(o); } }
@@ -222,6 +225,8 @@ public class COLLECTIONS
 		@Override
 		public ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(c.iterator()); }
 		@Override
+		public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		@Override
 		@Deprecated
 		public boolean remove(Object o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -358,5 +363,7 @@ public class COLLECTIONS
 		public void clear() {}
 		@Override
 		public int size() { return 0; }
+		@Override
+		public EmptyCollection KEY_GENERIC_TYPE copy() { return this; }
 	}
 }

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

@@ -216,6 +216,9 @@ public class LISTS
 #endif
 		@Override
 		public int size() { return 1; }
+		
+		@Override
+		public SingletonList KEY_GENERIC_TYPE copy() { return new SingletonListBRACES(element); }
 	}
 	
 	private static class SynchronizedArrayList KEY_GENERIC_TYPE extends SynchronizedList KEY_GENERIC_TYPE implements IARRAY KEY_GENERIC_TYPE
@@ -372,6 +375,9 @@ public class LISTS
 		
 		@Override
 		public void size(int size) { synchronized(mutex) { l.size(size); } }
+		
+		@Override
+		public LIST KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	}
 	
 	private static class UnmodifiableRandomList KEY_GENERIC_TYPE extends UnmodifiableList KEY_GENERIC_TYPE implements RandomAccess 
@@ -481,6 +487,9 @@ public class LISTS
 		
 		@Override
 		public void size(int size) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public LIST KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	}
 	
 	private static class EmptyList KEY_GENERIC_TYPE extends COLLECTIONS.EmptyCollection KEY_GENERIC_TYPE implements LIST KEY_GENERIC_TYPE
@@ -563,5 +572,8 @@ public class LISTS
 		
 		@Override
 		public void size(int size) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public EmptyList KEY_GENERIC_TYPE copy() { return this; }
 	}
 }

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

@@ -100,6 +100,8 @@ public class PRIORITY_QUEUES
 		public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() { synchronized(mutex) { return queue.comparator(); } }
 		@Override
 		public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input) { synchronized(mutex) { return queue.TO_ARRAY(input); } }
+		@Override
+		public PRIORITY_QUEUE KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	}
 	
 	/**
@@ -123,5 +125,7 @@ public class PRIORITY_QUEUES
 		public void enqueueFirst(KEY_TYPE e) { synchronized(mutex) { dequeue.enqueueFirst(e); } }
 		@Override
 		public KEY_TYPE dequeueLast() { synchronized(mutex) { return dequeue.dequeueLast(); } }
+		@Override
+		public PRIORITY_DEQUEUE KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	}
 }

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

@@ -190,6 +190,9 @@ public class SETS
 		}
 		@Override
 		public int size() { return 1; }
+		
+		@Override
+		public SingletonSet KEY_GENERIC_TYPE copy() { return new SingletonSetBRACES(element); }
 	}
 	
 	private static class EmptySet KEY_GENERIC_TYPE extends EmptyCollection KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
@@ -198,6 +201,8 @@ public class SETS
 		@Override
 		public boolean remove(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 #endif
+		@Override
+		public EmptySet KEY_GENERIC_TYPE copy() { return this; }
 	}
 	
 #if !TYPE_BOOLEAN
@@ -245,6 +250,9 @@ public class SETS
 		public KEY_TYPE getDefaultMinValue() { return n.getDefaultMinValue(); }
 		
 #endif
+		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { return unmodifiable(n.subSet(fromElement, fromInclusive, toElement, toInclusive)); }
 		
@@ -300,6 +308,9 @@ public class SETS
 		@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() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { return unmodifiable(s.subSet(fromElement, toElement)); }
 		
@@ -336,6 +347,9 @@ public class SETS
 			s = c;
 		}
 		
+		@Override
+		public SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 #if !TYPE_OBJECT
 		@Override
 		public boolean remove(KEY_TYPE o) { throw new UnsupportedOperationException(); }
@@ -412,6 +426,9 @@ public class SETS
 		public KEY_TYPE getDefaultMinValue() { synchronized(mutex) { return n.getDefaultMinValue(); } }
 		
 #endif
+		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { synchronized(mutex) { return synchronize(n.subSet(fromElement, fromInclusive, toElement, toInclusive), mutex); } }
 
@@ -493,6 +510,9 @@ public class SETS
 		@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() { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return synchronize(s.subSet(fromElement, toElement), mutex); } }
 
@@ -556,6 +576,9 @@ public class SETS
 #endif
 		}
 		
+		@Override
+		public SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		
 #if !TYPE_OBJECT
 		@Override
 		public boolean remove(KEY_TYPE o) { synchronized(mutex) { return s.remove(o); } }

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

@@ -277,6 +277,8 @@ public class MAPS
 		@Override
 		public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return EQUALS_KEY_TYPE(key, this.key) ? value : defaultValue; }
 #endif
+		@Override
+		public SingletonMap KEY_VALUE_GENERIC_TYPE copy() { return new SingletonMapKV_BRACES(key, value); }
 		@Override
 		public SET KEY_GENERIC_TYPE keySet() { 
 			if(keySet == null) keySet = SETS.singleton(key);
@@ -329,6 +331,8 @@ public class MAPS
 		public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { return VALUE_COLLECTIONS.empty(); }
 		@Override
 		public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { return ObjectSets.empty(); }
+		@Override
+		public EmptyMap KEY_VALUE_GENERIC_TYPE copy() { return this; }
 	}
 	
 	/**
@@ -415,6 +419,8 @@ public class MAPS
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE floorEntry(KEY_TYPE key) { return unmodifiable(map.floorEntry(key)); }
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE ceilingEntry(KEY_TYPE key) { return unmodifiable(map.ceilingEntry(key)); }
+		@Override
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	}
 	
 	/**
@@ -462,6 +468,8 @@ public class MAPS
 		public VALUE_TYPE FIRST_ENTRY_VALUE() { return map.FIRST_ENTRY_VALUE(); }
 		@Override
 		public VALUE_TYPE LAST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); }
+		@Override
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	}
 	
 	/**
@@ -501,6 +509,8 @@ public class MAPS
 		@Override
 		public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.getOrDefault(key, defaultValue); }
 #endif
+		@Override
+		public MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public SET KEY_GENERIC_TYPE keySet() { 
@@ -614,7 +624,9 @@ public class MAPS
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE floorEntry(KEY_TYPE key) { synchronized(mutex) { return map.floorEntry(key); } }
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE ceilingEntry(KEY_TYPE key) { synchronized(mutex) { return map.ceilingEntry(key); } }
-#if !TYPE_OBJECT
+		@Override
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		#if !TYPE_OBJECT
 		@Override
 		@Deprecated
 		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, boolean fromInclusive, CLASS_TYPE toKey, boolean toInclusive) { synchronized(mutex) { return synchronize(map.subMap(fromKey, fromInclusive, toKey, toInclusive), mutex); } }
@@ -718,6 +730,8 @@ public class MAPS
 		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 SORTED_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 #if !TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -831,6 +845,8 @@ public class MAPS
 		@Override
 		public int size() { synchronized(mutex) { return super.size(); } }
 		@Override
+		public MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		@Override
 		public SET KEY_GENERIC_TYPE keySet() {
 			if(keys == null) keys = SETS.synchronize(map.keySet(), mutex);
 			return keys;

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

@@ -135,6 +135,16 @@ public abstract class BaseInt2IntMapTest
 		Assert.assertTrue(map.remove(PUT_VALUE_ARRAY[51], PUT_ARRAY[51]));
 	}
 	
+	@Test
+	public void testSort()
+	{
+		if(!getValidMapTests().contains(MapTests.COPY)) return;
+		Int2IntMap map = createMap(TEST_ARRAY, TEST_ARRAY);
+		Int2IntMap copy = map.copy();
+		Assert.assertFalse(map == copy);
+		Assert.assertEquals(map, copy);
+	}
+	
 	public static class Strategy implements IntStrategy
 	{
 		@Override

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

@@ -178,4 +178,13 @@ public abstract class BaseIntCollectionTest extends BaseIntIterableTest
 		Assert.assertEquals(base, IntCollections.synchronize(collection).toString());
 		Assert.assertEquals(base, IntCollections.unmodifiable(collection).toString());
 	}
+	
+	@Test
+	public void testCopy() {
+		if(!getValidCollectionTests().contains(CollectionTest.COPY)) return;
+		IntCollection collection = create(BULK_ADD_ARRAY);
+		IntCollection copy = collection.copy();
+		Assert.assertFalse(collection == copy);
+		Assert.assertEquals(collection, copy);
+	}
 }

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

@@ -120,4 +120,13 @@ public abstract class BaseIntPriorityQueueTest extends BaseIntIterableTest
 			}
 		}
 	}
+	
+	@Test
+	public void testCopy() {
+		if(!getValidPriorityQueueTests().contains(PriorityQueueTest.COPY)) return;
+		IntPriorityQueue queue = create(TEST_ARRAY);
+		IntPriorityQueue copy = queue.copy();
+		Assert.assertFalse(queue == copy);
+		Assert.assertEquals(queue, copy);
+	}
 }

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

@@ -15,5 +15,6 @@ public enum CollectionTest
 	TO_ARRAY,
 	CLEAR,
 	WRAPPER,
-	TO_STRING;
+	TO_STRING,
+	COPY;
 }

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

@@ -11,5 +11,6 @@ public enum MapTests
 	MERGE,
 	GET,
 	ITERATORS,
-	REMOVE;
+	REMOVE,
+	COPY;
 }

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

@@ -7,4 +7,5 @@ public enum PriorityQueueTest
 	PEEK,
 	REMOVE,
 	TO_ARRAY,
+	COPY;
 }