Version Bump

-Added: List.indexedIterator which allows you to create a iterator with a customized iteration indecies. Useful if you want to transform lists output.
-Added: PriorityQueue.contains is now a function
-Added: Iterators/Async Builders now support MapToPrimitiveType function on the object variant. So more processing can be done. (Will be expanded upon later versions)
-Updated: SimpleCodeGenerator 1.3.0 is now being used which allows for iterative code support.

.github/workflows/build_action.yml

@@ -1,32 +1,33 @@
-name: Latest Build
+name: Latest Build
-
+
-on:
+on:
-   push:
+   push:
-      branches: [ master ]
+      branches: [ master ]
-   pull_request:
+   pull_request:
-      branches: [ master ]
+      branches: [ master ]
-
+
-jobs:
+jobs:
-   build:
+   build:
-      strategy:
+      strategy:
-         fail-fast: false
+         fail-fast: false
-         matrix:
+         matrix:
-            jdk: [8, 11, 14, 16, 17, 18]
+            jdk: [8, 11, 16, 17, 18, 19, 20]
-
+
-      runs-on: ubuntu-latest
+      runs-on: ubuntu-latest
-      steps:
+      steps:
-         - uses: actions/checkout@v2
+         - uses: actions/checkout@v3
-         
+         
-         - name: Set up JDK ${{ matrix.jdk }}
+         - name: Set up JDK ${{ matrix.jdk }}
-           uses: actions/setup-java@v1
+           uses: actions/setup-java@v3
-           with:
+           with:
-               java-version: ${{ matrix.jdk }}
+               distribution: 'temurin'
-
+               java-version: ${{ matrix.jdk }}
-         - name: Validate Gradle wrapper
+
-           uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
+         - name: Validate Gradle wrapper
-
+           uses: gradle/wrapper-validation-action@v1
-         - name: Make gradlew executable
+
-           run: chmod +x ./gradlew
+         - name: Make gradlew executable
-
+           run: chmod +x ./gradlew
-         - name: Build with Gradle
+
-           run: ./gradlew build
+         - name: Build with Gradle
+           run: ./gradlew build

.github/workflows/build_tests_action.yml

@@ -9,7 +9,7 @@ jobs:
       name: Unit Tests
       runs-on: ubuntu-latest
       steps:
-      -  uses: actions/checkout@v2
+      -  uses: actions/checkout@v3
          with:
             fetch-depth: 0
             

.github/workflows/coverage.yml

@@ -0,0 +1,27 @@
+name: Measure coverage
+
+on:
+  push:
+    branches: [ debug ]
+jobs:
+  build:
+    name: Code Quality Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: 11
+          cache: 'gradle'
+      - name: Make gradlew executable
+        run: chmod +x ./gradlew
+      - name: Build and analyze
+        run: ./gradlew generateTestSource test jacocoTestReport --info -Dfull_test_suite=true
+      - name: Upload to CodeCov
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        run: bash <(curl -s https://codecov.io/bash) -t $CODECOV_TOKEN

Changelog.md

@@ -1,250 +1,280 @@
-# Changelog of versions
+# Changelog of versions
-
+
-### Version 0.7.1 (Unreleased)
+### Version 0.8.1
-- Added: ISizeProvider interface (Optimization Helper)
+- Added: getFirst/getLast/removeFirst/removeLast to List.class.
-- Added: ISizeProvider into most Iterable implementations (Distinct/Filter/FlatMap/ArrayFlatMap don't support it, for obvious reasons)
+- Added: Dedicated Set toArray implementations.
-- Added: ToArray function into Iterable which uses ISizeProvider to reduce overhead of duplicating arrays.
+- Added: ToArray/pushTop functions to Stack.class.
-- Fixed: putIfAbsent now replaces defaultValues
+- Added: ComputeNonDefault functions which will contain the current behavior of the Compute function, while the Compute will be changed to be more java compliant!
-- Fixed: OpenHashSet/Map and their Custom Variants no longer rely on List implementations.
+- Added: List.reversed, which returns a SubList that has all elements in reversed order and also inserts reversed.
-- Fixed: ObjectCopyOnWriteList.of did create a ObjectArrayList instead of the CopyOnWrite variant.
+- Added: Iterators.infinite as an option that will create a Infinite Iterator based on the inputed one.
-- Removed: BooleanSet and Maps that start with a Boolean classes since they can not be used anyways.
+- Added: List.indexedIterator which allows you to create a iterator with a customized iteration indecies. Useful if you want to transform lists output.
-- Breaking Change: Function classes now use the "apply/applyAs/test" format from Java itself, instead of the "get" format. This cleans up a lot of things. But will break existing function class implementations
+- Added: PriorityQueue.contains is now a function
-
+- Added: Iterators/Async Builders now support MapToPrimitiveType function on the object variant. So more processing can be done. (Will be expanded upon later versions)
-### Version 0.7.0
+- Fixed: SetValue wasn't working on forEach implementations.
-- Added: Over 11 Million Unit Tests to this library to ensure quality.
+- Fixed: Compute functions now perform with primitives more java compliant. Meaning that getDefaultReturnValue function no longer is seen as null.
-- Added: ArrayList size constructor now throws IllegalStateException if the size parameter is negative
+- Fixed: Supplier was using the wrong dataType in their function name.
-- Added: EnumMap specialized forEach implementation.
+- Updated: SimpleCodeGenerator 1.3.0 is now being used which allows for iterative code support.
-- Added: AbstractMap.remove now delegates to its primitive counterpart.
+
-- Added: ConcurrentHashMap now implements ITrimmable
+### Version 0.8.0
-- Refactor: Removed a lot of disabled code from ArraySet.
+- Added: getFirst/getLast/removeFirst/removeLast to Lists
-- Removed: LinkedList.addAll(index, List) now delegates to LinkedList.addAll(index, Collection) due to no special optimization required.
+- Added: Dedicated implementations for toArray into TreeSets
-- Fixed: AbstractList.SubList.get/set/swapRemove didn't calculate their List index Properly
+- Fixed: forEach methods in Maps now can use "setValue" functions.
-- Fixed: AbstractList.SubList chains now properly if you create SubLists within SubLists.
+
-- Fixed: AbstractList.Iterator.add now respects Immutable/UnmodifiableLists.
+### Version 0.8.0
-- Fixed: AbstractList.Iterator.skip/back now keep track of the last returned value for remove function to work properly.
+- Added: ISizeProvider interface (Optimization Helper)
-- Fixed: CopyOnWriteArrayList.extract/removeElements(int, int) does now proper range checks and remove elements properly.
+- Added: ISizeProvider into most Iterable implementations (Distinct/Filter/FlatMap/ArrayFlatMap don't support it, for obvious reasons)
-- Fixed: CopyOnWriteArrayList.SubList now works properly. (Reimplemented entirely)
+- Added: ToArray function into Iterable which uses ISizeProvider to reduce overhead of duplicating arrays.
-- Fixed: CopyOnWriteArrayList.Iterator.previous() was returning the wrong values.
+- Added: Functions that have the same type, Int2IntFunction as example, have now a identity function.
-- Fixed: CopyOnWriteArrayList.Iterator.skip now skips the right amount of elements and stops where it should.
+- Added: Functions of a BooleanValue have now alwaysTrue/False function.
-- Fixed: LinkedList.first/last/dequeue/dequeueLast now throws NoSuchElementException when empty instead of IllegalStateException.
+- Added: ForEachIndexed for all Iterable implementations
-- Fixed: LinkedList had an edge case where the entire reverse iterator would break if the wrong element was removed.
+- Added: RandomGenerator support (Java17), though requires self compilation
-- Fixed: LinkedList.extractElement now returns the correct values.
+- Added: Optimizations for HashUtils next power of function.
-- Fixed: AbstractMap.entrySet().remove(Object) now returns true if defaultReturnValue elements were removed.
+- Added: toArray() now returns a cached empty array if the collection is empty.
-- Fixed: ConcurrentHashMap.remove(Object, Object) checks if the type matches before comparing against null Values.
+- Added: toArray function for AsyncBuilder
-- Fixed: LinkedHashMap.clearAndTrim() was checking the wrong value for determining the full reset or clearing of a Map.
+- Added: Modularization to the library where feature can be disabled as needed. (Requires Self-Compilation)
-- Fixed: HashMap.trim/clearToTrim() was using the wrong value to determin if something should be done.
+- Fixed: putIfAbsent now replaces defaultValues
-- Fixed: HashMap now compares empty values (0) against nullKeys when Object Variants of the type are used.
+- Fixed: OpenHashSet/Map and their Custom Variants no longer rely on List implementations.
-- Fixed: ImmutableMap now compares empty values (0) against nullKeys when Object Variants of the type are used.
+- Fixed: ObjectCopyOnWriteList.of did create a ObjectArrayList instead of the CopyOnWrite variant.
-- Fixed: ArrayMap.iterator(key) now throws NoSuchElementException when the element wasn't found.
+- Removed: BooleanSet and Maps that start with a Boolean classes since they can not be used anyways.
-- Fixed: Linked/EnumMap array constructor was creating the wrong size values array.
+- Breaking Change: Function classes now use the "apply/applyAs/test" format from Java itself, instead of the "get" format. This cleans up a lot of things. But will break existing function class implementations
-- Fixed: LinkedEnumMap.getAndMoveToFirst/Last was moving elements even if the element wasn't present.
+- Breaking Change: Classes that used PrimitiveCollection functions now default to java functions where applicable, this is to increase compat.
-- Fixed: AVL/RBTreeMap.getFirst/LastKey was not throwing a NoSuchElementException if the map was empty.
+- Breaking Change: Some function classes now get closer to javas terms. (Predicate/UnaryOperator etc)
-- Fixed: Map.Builder wasn't throwing a IllegalStateException when creating a negative size builder.
+
-- Fixed: AVL/RBTreeSet.DecendingSet.subSet(from, fromInclusive, to, toInclusive) was creating a corrupt asending subset.
+### Version 0.7.0
-- Fixed: ArraySet throws now a IllegalStateException when trying to create it with a negative size.
+- Added: Over 11 Million Unit Tests to this library to ensure quality.
-- Fixed: ArraySet.addMoveToLast(key) was crashing when a key was already present.
+- Added: ArrayList size constructor now throws IllegalStateException if the size parameter is negative
-- Fixed: Immutable/LinkedHashSet now keep track of their iteration index properly.
+- Added: EnumMap specialized forEach implementation.
-- Fixed: LinkedHashSet.moveToFirst/Last(key) would crash if the Set was empty.
+- Added: AbstractMap.remove now delegates to its primitive counterpart.
-- Fixed: LinkedHashSet.clearAndTrim() was checking the wrong value for determining the full reset or clearing of a Map.
+- Added: ConcurrentHashMap now implements ITrimmable
-- Fixed: HashSet.trim/clearToTrim() was using the wrong value to determin if something should be done.
+- Refactor: Removed a lot of disabled code from ArraySet.
-
+- Removed: LinkedList.addAll(index, List) now delegates to LinkedList.addAll(index, Collection) due to no special optimization required.
-
+- Fixed: AbstractList.SubList.get/set/swapRemove didn't calculate their List index Properly
-### Version 0.6.2
+- Fixed: AbstractList.SubList chains now properly if you create SubLists within SubLists.
-- Added: Array only sorting function return the inputed array. This was done to allow for static final references to use the method in one go without having to make lambda wrappers. Cleaner code.
+- Fixed: AbstractList.Iterator.add now respects Immutable/UnmodifiableLists.
-- Added: Iterator Wrappers are now a bit more in Compliance with Java Standards.
+- Fixed: AbstractList.Iterator.skip/back now keep track of the last returned value for remove function to work properly.
-- Added: AsyncBuilders now Support Array Inputs to create cleaner code.
+- Fixed: CopyOnWriteArrayList.extract/removeElements(int, int) does now proper range checks and remove elements properly.
-- Changed: LinkedList.addBulk variable definition was triggering a false positive.
+- Fixed: CopyOnWriteArrayList.SubList now works properly. (Reimplemented entirely)
-- Fixed: TreeMap.subMap().entrySet().remove() wouldn't check primitives properly.
+- Fixed: CopyOnWriteArrayList.Iterator.previous() was returning the wrong values.
-- Fixed: SortedMap.sub/tail/headMap were looping into themselves.
+- Fixed: CopyOnWriteArrayList.Iterator.skip now skips the right amount of elements and stops where it should.
-- Fixed: AbstractCollection.retainAll didn't push removed values through the consumer.
+- Fixed: LinkedList.first/last/dequeue/dequeueLast now throws NoSuchElementException when empty instead of IllegalStateException.
-- Fixed: AbstractCollection.toArray wouldn't reset the last entry if the input array was larger then the elements in the collection.
+- Fixed: LinkedList had an edge case where the entire reverse iterator would break if the wrong element was removed.
-- Fixed: SubList didn't check for ranges properly or didn't use parent list to validate changes.
+- Fixed: LinkedList.extractElement now returns the correct values.
-- Fixed: ArrayList.addElements didn't check input array fully and used the wrong variable to move the elements around.
+- Fixed: AbstractMap.entrySet().remove(Object) now returns true if defaultReturnValue elements were removed.
-- Fixed: LinkedList.addElements(EmptyInput) would crash.
+- Fixed: ConcurrentHashMap.remove(Object, Object) checks if the type matches before comparing against null Values.
-- Fixed: LinkedList.swapRemove didn't account for if the removed element was the prelast one.
+- Fixed: LinkedHashMap.clearAndTrim() was checking the wrong value for determining the full reset or clearing of a Map.
-- Fixed: LinkedList.removeElements would break the implementation if the list was almost empty and the middle element was removed.
+- Fixed: HashMap.trim/clearToTrim() was using the wrong value to determin if something should be done.
-- Fixed: LinkedHashSet.addAndMoveToFirst wouldn't move elements to the first place.
+- Fixed: HashMap now compares empty values (0) against nullKeys when Object Variants of the type are used.
-- Fixed: ArrayList/LinkedList extractElements crashing when 0 or less elements are desired.
+- Fixed: ImmutableMap now compares empty values (0) against nullKeys when Object Variants of the type are used.
-- Fixed: TreeMap pollFirst/LastKey should return the defaultMin/max value instead of a Empty value.
+- Fixed: ArrayMap.iterator(key) now throws NoSuchElementException when the element wasn't found.
-- Fixed: TreeMap keySet implementation was missing the class type implementations to pass keySet tests.
+- Fixed: Linked/EnumMap array constructor was creating the wrong size values array.
-- Fixed: TreeMap.SubMap Iterator (primitive Keys) was crashing because a Null was set on to a primitive.
+- Fixed: LinkedEnumMap.getAndMoveToFirst/Last was moving elements even if the element wasn't present.
-
+- Fixed: AVL/RBTreeMap.getFirst/LastKey was not throwing a NoSuchElementException if the map was empty.
-
+- Fixed: Map.Builder wasn't throwing a IllegalStateException when creating a negative size builder.
-### Version 0.6.1
+- Fixed: AVL/RBTreeSet.DecendingSet.subSet(from, fromInclusive, to, toInclusive) was creating a corrupt asending subset.
-- Fixed: FIFO queue crashing when the last index is before the first index when peek is called.
+- Fixed: ArraySet throws now a IllegalStateException when trying to create it with a negative size.
-- Fixed: FIFO queue only clears the array if it was in use.
+- Fixed: ArraySet.addMoveToLast(key) was crashing when a key was already present.
-- Added: Sorted Method for the stream replacing functions.
+- Fixed: Immutable/LinkedHashSet now keep track of their iteration index properly.
-
+- Fixed: LinkedHashSet.moveToFirst/Last(key) would crash if the Set was empty.
-### Version 0.6.0
+- Fixed: LinkedHashSet.clearAndTrim() was checking the wrong value for determining the full reset or clearing of a Map.
-- Added: addOrGet for sets.
+- Fixed: HashSet.trim/clearToTrim() was using the wrong value to determin if something should be done.
-- Added: Async API which allows to easily execute Iterables/Collections offthread without the complexity.
+
-- Added: CopyOnWriteArrayList and tests for it
+
-- Added: Support up to Java17.
+### Version 0.6.2
-- Added: Build System now adds module-info if the Running JVM is 9 or higher
+- Added: Array only sorting function return the inputed array. This was done to allow for static final references to use the method in one go without having to make lambda wrappers. Cleaner code.
-- Added: ArrayList.of(Class, size) that allows you to allocate a size right at the creation of the List without having to create a wrapper array.
+- Added: Iterator Wrappers are now a bit more in Compliance with Java Standards.
-- Added: A ConcurrentHashMap implementation.
+- Added: AsyncBuilders now Support Array Inputs to create cleaner code.
-- Fixed: containsValue in the HashMap wouldn't check the nullKey
+- Changed: LinkedList.addBulk variable definition was triggering a false positive.
-- Removed: Deprecated functions from SortedMaps/Sets
+- Fixed: TreeMap.subMap().entrySet().remove() wouldn't check primitives properly.
-
+- Fixed: SortedMap.sub/tail/headMap were looping into themselves.
-### Version 0.5.3
+- Fixed: AbstractCollection.retainAll didn't push removed values through the consumer.
-- Added: OrderedMap/Set
+- Fixed: AbstractCollection.toArray wouldn't reset the last entry if the input array was larger then the elements in the collection.
-- Added: Deprecation to Functions that are specific to Ordered interfaces in the SortedMap/Set
+- Fixed: SubList didn't check for ranges properly or didn't use parent list to validate changes.
-- Added: subFrom to Maps which is the counterpart of the addTo method
+- Fixed: ArrayList.addElements didn't check input array fully and used the wrong variable to move the elements around.
-- Added: pourAsList and pourAsSet (booleans excluded for sets) to Iterable
+- Fixed: LinkedList.addElements(EmptyInput) would crash.
-- Fixed: ArrayList.grow had a small bug where it would trigger to early causing performance problems with exact sized collections.
+- Fixed: LinkedList.swapRemove didn't account for if the removed element was the prelast one.
-- Fixed: FIFOQueue size constructor had a small bug where it would trigger a array enlargement when all elements were inserted.
+- Fixed: LinkedList.removeElements would break the implementation if the list was almost empty and the middle element was removed.
-
+- Fixed: LinkedHashSet.addAndMoveToFirst wouldn't move elements to the first place.
-### Version 0.5.2
+- Fixed: ArrayList/LinkedList extractElements crashing when 0 or less elements are desired.
-- Fixed: Bugs with Queues starting with the wrong size
+- Fixed: TreeMap pollFirst/LastKey should return the defaultMin/max value instead of a Empty value.
-- Fixed: ArrayGrowth for Queues was +1 instead of +50%
+- Fixed: TreeMap keySet implementation was missing the class type implementations to pass keySet tests.
-- Added: Benchmarks with java and FastUtil
+- Fixed: TreeMap.SubMap Iterator (primitive Keys) was crashing because a Null was set on to a primitive.
-
+
-### Version 0.5.1
+
-- Fixed: Reworked the NavigableSet/Map implementations of RBTree/AVLTree/Array Sets/Maps so they are now deemed stable.
+### Version 0.6.1
-- Added: Another 150k Unit tests.
+- Fixed: FIFO queue crashing when the last index is before the first index when peek is called.
-- 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: FIFO queue only clears the array if it was in use.
-- Fixed: Bugs with null values for primitive collections.
+- Added: Sorted Method for the stream replacing functions.
-- Removed: ArraySet/Map subSet/subMap implementation was removed.
+
-
+### Version 0.6.0
-### Version 0.5.0
+- Added: addOrGet for sets.
-- Added: 2 Helper functions to find out how many bits are required to store a Number.
+- Added: Async API which allows to easily execute Iterables/Collections offthread without the complexity.
-- Added: pour function directly into Iterable which allows to collect all elements in the Iterable directly.
+- Added: CopyOnWriteArrayList and tests for it
-- Added: The new ToArray method from Java9 and newer into the library. Using a functional interface. (Just a backport)
+- Added: Support up to Java17.
-- Changed: Reworked how the Map Builder functions are created. They are now in a SubClass that moves them out of the way. Less Clutter. (This might break things if that was used before)
+- Added: Build System now adds module-info if the Running JVM is 9 or higher
-- Added: Map Builder that allows now to Build Maps like Guava ImmutableMaps can be build. Note: This has a slight performance overhead.
+- Added: ArrayList.of(Class, size) that allows you to allocate a size right at the creation of the List without having to create a wrapper array.
-- Added: Unmodifiable and Synchronize wrapper functions direclty into Collection Interfaces. This is mostly a quality of life thing.
+- Added: A ConcurrentHashMap implementation.
-- Added: Unmodifiable and Synchronized Wrapper Collections can now be cloned. They clone the underlying map which doesn't break functionality. (Had a usecase for it)
+- Fixed: containsValue in the HashMap wouldn't check the nullKey
-- Added: A boxed putAll array variant.
+- Removed: Deprecated functions from SortedMaps/Sets
-- Fixed: EnumMaps didn't keep track of their size and now got proper care and implementations as needed. There might be more work required but at least the core functionality is now up to date.
+
-- Added: Tests for the new Stream replace functions to ensure no bugs are left.
+### Version 0.5.3
-- Fixed: Custom HashSet reduce function with a default value was checking incorrectly for present keys.
+- Added: OrderedMap/Set
-- Added: Guava TestSuit
+- Added: Deprecation to Functions that are specific to Ordered interfaces in the SortedMap/Set
-- Fixed: HashCode and toString method would crash if the Object Key/Value was null
+- Added: subFrom to Maps which is the counterpart of the addTo method
-- Added: AbstractTypeCollection now delegates the contains check to type-specific Collections if it detects it.
+- Added: pourAsList and pourAsSet (booleans excluded for sets) to Iterable
-- Fixed: Map.Entry toString wasn't writing values not like it should do.
+- Fixed: ArrayList.grow had a small bug where it would trigger to early causing performance problems with exact sized collections.
-- Fixed: Set.hashCode now is the sum of the elements instead of a Unique HashCode based on the elements.
+- Fixed: FIFOQueue size constructor had a small bug where it would trigger a array enlargement when all elements were inserted.
-- Fixed: Added missing NonNull Checks.
+
-- Fixed: Custom/OpenHashMap.containsValue implementation was wrong.
+### Version 0.5.2
-- Fixed: Custom/OpenHashMap.compute/present/absent now works how it is specified in the Java Documentation
+- Fixed: Bugs with Queues starting with the wrong size
-- Fixed: Custom/OpenHashMap.merge/BulkMerge now works how it is specified in the Java Documentation
+- Fixed: ArrayGrowth for Queues was +1 instead of +50%
-- Fixed: Custom/Linked/OpenHashMap.keySet.remove was causing a infinite loop.
+- Added: Benchmarks with java and FastUtil
-- Fixed: Custom/Linked/OpenHashMap.entrySet.contains was not correctly comparing the entry.
+
-- Fixed: Custom/OpenHashMap.mapIterator now no longer crashes in certain cases.
+### Version 0.5.1
-- Added: Custom/LinkedOpenHashMap now takes use of the improved Iterator it has for containsValue
+- Fixed: Reworked the NavigableSet/Map implementations of RBTree/AVLTree/Array Sets/Maps so they are now deemed stable.
-- Fixed: CustomOpenHashMap.keySet.forEach was basically putting out keys even if they were present
+- Added: Another 150k Unit tests.
-- Fixed: ImmutableMaps issues thanks to the tests. Roughly the same as the rest of the maps
+- 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: RB/AVLTreeMaps issues. Roughly the same as the rest of the maps
+- Fixed: Bugs with null values for primitive collections.
-- Fixed: SubLists are now properly implemented.
+- Removed: ArraySet/Map subSet/subMap implementation was removed.
-- Fixed: HashSet Iterator bugs now fixed... That was Painful.
+
-- Added: Tests for Lists and Sets
+### Version 0.5.0
-
+- Added: 2 Helper functions to find out how many bits are required to store a Number.
-### Version 0.4.5
+- Added: pour function directly into Iterable which allows to collect all elements in the Iterable directly.
-- Added: removeAll/retainAll(Collection c, Consumer r) which receives all the elements that got deleted from the collection
+- Added: The new ToArray method from Java9 and newer into the library. Using a functional interface. (Just a backport)
-- Fixed: Supplier get function wasn't referencing original function.
+- Changed: Reworked how the Map Builder functions are created. They are now in a SubClass that moves them out of the way. Less Clutter. (This might break things if that was used before)
-- Added: addIfPresent/Absent to lists
+- Added: Map Builder that allows now to Build Maps like Guava ImmutableMaps can be build. Note: This has a slight performance overhead.
-- Added: distinct, limit and peek iterators
+- Added: Unmodifiable and Synchronize wrapper functions direclty into Collection Interfaces. This is mostly a quality of life thing.
-- Added: Iterable's can now reduce its contents
+- Added: Unmodifiable and Synchronized Wrapper Collections can now be cloned. They clone the underlying map which doesn't break functionality. (Had a usecase for it)
-- Added: Better ForEach support for IterableWrappers so a Iterator chain is not created
+- Added: A boxed putAll array variant.
-- Added: SwapRemove to Lists which moves the last element into the desired space to be deleted
+- Fixed: EnumMaps didn't keep track of their size and now got proper care and implementations as needed. There might be more work required but at least the core functionality is now up to date.
-- Added: More Test cases
+- Added: Tests for the new Stream replace functions to ensure no bugs are left.
-
+- Fixed: Custom HashSet reduce function with a default value was checking incorrectly for present keys.
-### Version 0.4.4
+- Added: Guava TestSuit
-- Fixed: ObjectArrayList.of was causing crashes because of a Poor implementation.
+- Fixed: HashCode and toString method would crash if the Object Key/Value was null
-- Added: Unsorted HashMaps/Sets now throw Concurrent exceptions if they were modified during a rehash.
+- Added: AbstractTypeCollection now delegates the contains check to type-specific Collections if it detects it.
-- Added: Array/Collection version of enqueue and enqueueFirst to PriorityQueues.
+- Fixed: Map.Entry toString wasn't writing values not like it should do.
-- Added: fillBuffer function into PrimitiveLists which allow to optimize JavaNio buffers if needed.
+- Fixed: Set.hashCode now is the sum of the elements instead of a Unique HashCode based on the elements.
-
+- Fixed: Added missing NonNull Checks.
-### Version 0.4.3
+- Fixed: Custom/OpenHashMap.containsValue implementation was wrong.
-- Added: Wrapper now support the Optimized Lambda replacer functions to improve performance.
+- Fixed: Custom/OpenHashMap.compute/present/absent now works how it is specified in the Java Documentation
-- Added: FIFO Queue has now a minimum capacity and that is now checked more consistently.
+- Fixed: Custom/OpenHashMap.merge/BulkMerge now works how it is specified in the Java Documentation
-
+- Fixed: Custom/Linked/OpenHashMap.keySet.remove was causing a infinite loop.
-### Version 0.4.2
+- Fixed: Custom/Linked/OpenHashMap.entrySet.contains was not correctly comparing the entry.
-- Added: Lists/Sets/Maps/PriorityQueues are now copy-able. with the new copy() function.
+- Fixed: Custom/OpenHashMap.mapIterator now no longer crashes in certain cases.
-	Note: subLists/subMaps/subSets or synchronize/unmodifyable wrappers do not support that function.
+- Added: Custom/LinkedOpenHashMap now takes use of the improved Iterator it has for containsValue
-- Fixed: PriorityQueues didn't implement: hashCode/equals/toString
+- Fixed: CustomOpenHashMap.keySet.forEach was basically putting out keys even if they were present
-
+- Fixed: ImmutableMaps issues thanks to the tests. Roughly the same as the rest of the maps
-### Version 0.4.1
+- Fixed: RB/AVLTreeMaps issues. Roughly the same as the rest of the maps
-- Changed: ForEach with input now provides input, value instead of value, input, this improves the usage of method references greatly
+- Fixed: SubLists are now properly implemented.
-- Added: addAll with Array-types in collections.
+- Fixed: HashSet Iterator bugs now fixed... That was Painful.
-- Added: Java Iterator/Iterable support for Stream replacing methods
+- Added: Tests for Lists and Sets
-- Added: Suppliers.
+
-- Added: SupplyIfAbsent. It is ComputeIfAbsent but using suppliers
+### Version 0.4.5
-- Added: Count feature into Iterable
+- Added: removeAll/retainAll(Collection c, Consumer r) which receives all the elements that got deleted from the collection
-- Fixed: A couple bugs with the new StreamReplacing functions in LinkedCollections Iterating to Infinity
+- Fixed: Supplier get function wasn't referencing original function.
-
+- Added: addIfPresent/Absent to lists
-### Version 0.4.0
+- Added: distinct, limit and peek iterators
-- Changed: Iterable specific helper functions were moved out of Iterators and moved into Iterables
+- Added: Iterable's can now reduce its contents
-- Added: New Stream replacing functions: findFirst, matchesAny/All/None
+- Added: Better ForEach support for IterableWrappers so a Iterator chain is not created
-- Fixed: Compute/ComputeIfAbsent/ComputeIfPresent/Merge/BulkMerge in maps now behave like they should.
+- Added: SwapRemove to Lists which moves the last element into the desired space to be deleted
-- Added: Implementations for New Stream replacing functions.
+- Added: More Test cases
-- Changed: Removed a lot of duplicated forEach implementations
+
-- Added: Flat/Mapping functions (to object) are now accessible to primitive maps.
+### Version 0.4.4
-- Added: Filter function to Iterators/Iterables (Iterable implements it by default)
+- Fixed: ObjectArrayList.of was causing crashes because of a Poor implementation.
-- Changed: Cleanup of some variables/mappers
+- Added: Unsorted HashMaps/Sets now throw Concurrent exceptions if they were modified during a rehash.
-- Added/Fixed: AVL/RBTreeMap got reworked and SubMaps work more properly now. Also forEach support got improved a lot
+- Added: Array/Collection version of enqueue and enqueueFirst to PriorityQueues.
-- Added/Fixed: TreeSubSets (RB/AVL) got their functional implementations improved too.
+- Added: fillBuffer function into PrimitiveLists which allow to optimize JavaNio buffers if needed.
-- Added: Pairs are now a thing. In Mutable/Immutable Form
+
-
+### Version 0.4.3
-### Version 0.3.6
+- Added: Wrapper now support the Optimized Lambda replacer functions to improve performance.
-- Fixed: addAll non Type Specific Lists was causing crashes.
+- Added: FIFO Queue has now a minimum capacity and that is now checked more consistently.
-- Fixed/Changed: clearAndTrim's implementation was all over the place. In some cases causing crash scenarios.
+
-- Fixed: Wrappers didn't implement toString/equals/hashCode
+### Version 0.4.2
-- Added: Tests for addAll Bug
+- Added: Lists/Sets/Maps/PriorityQueues are now copy-able. with the new copy() function.
-- Changed: Cleaned up CodeStyle as bugs were fixed.
+	Note: subLists/subMaps/subSets or synchronize/unmodifyable wrappers do not support that function.
-
+- Fixed: PriorityQueues didn't implement: hashCode/equals/toString
-### Version 0.3.5
+
-- Fixed: Simple Code Generator dependency was declared wrong. Its only needed for runtime. Not for Compilation.
+### Version 0.4.1
-- Fixed: ObjectLists Crashed when a null was provided as a Comparator. (Unless the List was Initialized with the ClassType)
+- Changed: ForEach with input now provides input, value instead of value, input, this improves the usage of method references greatly
-- Fixed: LinkedLists didn't implement add(Object)
+- Added: addAll with Array-types in collections.
-- Fixed: Object Collections did have the JavaCollections deprecated as the Constructor. This should only be deprecated for Primitives
+- Added: Java Iterator/Iterable support for Stream replacing methods
-- Added: Tests with 5k Random names for Object sorting.
+- Added: Suppliers.
-- Changed: Object Arrays no longer require a Comparable[] it just assumes now that the elements in the Array are Comparable
+- Added: SupplyIfAbsent. It is ComputeIfAbsent but using suppliers
-- Fixed: Dependency to SimpleCodeGenerator should be no longer a thing. Because the resulting library doesn't need it only the builder does.
+- Added: Count feature into Iterable
-
+- Fixed: A couple bugs with the new StreamReplacing functions in LinkedCollections Iterating to Infinity
-### Version 0.3.4
+
-- Fixed: ArrayLists didn't resize properly if they were empty.
+### Version 0.4.0
-
+- Changed: Iterable specific helper functions were moved out of Iterators and moved into Iterables
-
+- Added: New Stream replacing functions: findFirst, matchesAny/All/None
-### Version 0.3.3
+- Fixed: Compute/ComputeIfAbsent/ComputeIfPresent/Merge/BulkMerge in maps now behave like they should.
-- Added: Flat/Mapping function for Iterables/Iterators to help avoid streams for cleaner looking code
+- Added: Implementations for New Stream replacing functions.
-- Fixed: AVLTrees pollFirst/Last is now keeping orders and is fixed
+- Changed: Removed a lot of duplicated forEach implementations
-- Fixed: AbstractCollection bulk adding methods now link to the specialized implementations.
+- Added: Flat/Mapping functions (to object) are now accessible to primitive maps.
-- Fixed: A bug with getElements in ArrayList.
+- Added: Filter function to Iterators/Iterables (Iterable implements it by default)
-- Fixed: PriorityQueue remove/toArray function were renamed so they fit better with other interfaces. (remove => removeFirst and toArray uses a different genericType)
+- Changed: Cleanup of some variables/mappers
-- Added: LinkedList which is a List/PriorityDequeue/Stack which allows for more optimized use-cases and reduced boxing/unboxing.
+- Added/Fixed: AVL/RBTreeMap got reworked and SubMaps work more properly now. Also forEach support got improved a lot
-- Added: Tests for LinkedList
+- Added/Fixed: TreeSubSets (RB/AVL) got their functional implementations improved too.
-
+- Added: Pairs are now a thing. In Mutable/Immutable Form
-### Version 0.3.2
+
-- Fixed: Map.put wasn't referring to primitive variants.
+### Version 0.3.6
-- Added: ImmutableList.
+- Fixed: addAll non Type Specific Lists was causing crashes.
-- Added: Iterator pour function into a List or Array
+- Fixed/Changed: clearAndTrim's implementation was all over the place. In some cases causing crash scenarios.
-- Changed: Arrays Wrap is now accessible to Objects and now is ? extends TYPE instead of TYPE.
+- Fixed: Wrappers didn't implement toString/equals/hashCode
-- Added: OpenHashSets now implement foreach and have less overhead.
+- Added: Tests for addAll Bug
-- Added: ImmutableOpenHashSet that is not editable (is linked by default for fast iteration)
+- Changed: Cleaned up CodeStyle as bugs were fixed.
-- Added: CustomOpenHashSets now implement foreach and have less overhead.
+
-- Added: ImmutableOpenHashMap that is not editable (is linked by default for fast iteration)
+### Version 0.3.5
-- Added: Maps can now be created through the interface.
+- Fixed: Simple Code Generator dependency was declared wrong. Its only needed for runtime. Not for Compilation.
-- Fixed: Lists.addElements(T...elements) was adding elements at the beginning of a list instead of the end.
+- Fixed: ObjectLists Crashed when a null was provided as a Comparator. (Unless the List was Initialized with the ClassType)
-- Fixed: Bugs with the AVLTreeSet. And marked bugs with AVLTreeX that are still present.
+- Fixed: LinkedLists didn't implement add(Object)
-
+- Fixed: Object Collections did have the JavaCollections deprecated as the Constructor. This should only be deprecated for Primitives
-### Version 0.3.1
+- Added: Tests with 5k Random names for Object sorting.
-- Fixed: containsKey & containsValue in HashMaps were deprecated for Object Variants.
+- Changed: Object Arrays no longer require a Comparable[] it just assumes now that the elements in the Array are Comparable
-- Fixed: HashMap wasn't deleting Keys & Values references when removing a Object
+- Fixed: Dependency to SimpleCodeGenerator should be no longer a thing. Because the resulting library doesn't need it only the builder does.
-- Fixed: AVLTreeMap didn't balance properly.
+
-- Changed: EnumMap no longer tries to access SharedSecrets since its gone in java11
+### Version 0.3.4
-- Added: HashMaps now implement ITrimmable
+- Fixed: ArrayLists didn't resize properly if they were empty.
-- Added: AVLTreeSet didn't balance properly
+
-- Fixed: HashMaps & LinkedMaps weren't clearing references properly.
+
-
+### Version 0.3.3
-### Version 0.3.0 (Breaking 0.2.0)
+- Added: Flat/Mapping function for Iterables/Iterators to help avoid streams for cleaner looking code
-- Added: Stack.isEmpty was missing
+- Fixed: AVLTrees pollFirst/Last is now keeping orders and is fixed
-- Changed: remove/removeLast/enqueue/enqueueFirst no longer use Type Suffixes
+- Fixed: AbstractCollection bulk adding methods now link to the specialized implementations.
-- Removed: Suffixes for unmodifiable & synchronize functions.
+- Fixed: A bug with getElements in ArrayList.
-- Changed: Primitive Stacks no longer depend on the base Stack class. Because seriously not needed.
+- Fixed: PriorityQueue remove/toArray function were renamed so they fit better with other interfaces. (remove => removeFirst and toArray uses a different genericType)
-- Changed: PriorityQueues no longer extends Object Variant.
+- Added: LinkedList which is a List/PriorityDequeue/Stack which allows for more optimized use-cases and reduced boxing/unboxing.
-- Changed: Maps.get function is no longer using Suffixes unless its absolutely necessary.
+- Added: Tests for LinkedList
-- Changed: Maps.remove function is no longer using Suffixes unless its absolutely necessary.
+
-- Changed: ObjectList methods are no longer marked Deprecated even so it was for primitive ones.
+### Version 0.3.2
-- Added: Shuffle & Reverse Methods.
+- Fixed: Map.put wasn't referring to primitive variants.
-- Added: Concat Iterators.
+- Added: ImmutableList.
+- Added: Iterator pour function into a List or Array
+- Changed: Arrays Wrap is now accessible to Objects and now is ? extends TYPE instead of TYPE.
+- Added: OpenHashSets now implement foreach and have less overhead.
+- Added: ImmutableOpenHashSet that is not editable (is linked by default for fast iteration)
+- Added: CustomOpenHashSets now implement foreach and have less overhead.
+- Added: ImmutableOpenHashMap that is not editable (is linked by default for fast iteration)
+- Added: Maps can now be created through the interface.
+- Fixed: Lists.addElements(T...elements) was adding elements at the beginning of a list instead of the end.
+- Fixed: Bugs with the AVLTreeSet. And marked bugs with AVLTreeX that are still present.
+
+### Version 0.3.1
+- Fixed: containsKey & containsValue in HashMaps were deprecated for Object Variants.
+- Fixed: HashMap wasn't deleting Keys & Values references when removing a Object
+- Fixed: AVLTreeMap didn't balance properly.
+- Changed: EnumMap no longer tries to access SharedSecrets since its gone in java11
+- Added: HashMaps now implement ITrimmable
+- Added: AVLTreeSet didn't balance properly
+- Fixed: HashMaps & LinkedMaps weren't clearing references properly.
+
+### Version 0.3.0 (Breaking 0.2.0)
+- Added: Stack.isEmpty was missing
+- Changed: remove/removeLast/enqueue/enqueueFirst no longer use Type Suffixes
+- Removed: Suffixes for unmodifiable & synchronize functions.
+- Changed: Primitive Stacks no longer depend on the base Stack class. Because seriously not needed.
+- Changed: PriorityQueues no longer extends Object Variant.
+- Changed: Maps.get function is no longer using Suffixes unless its absolutely necessary.
+- Changed: Maps.remove function is no longer using Suffixes unless its absolutely necessary.
+- Changed: ObjectList methods are no longer marked Deprecated even so it was for primitive ones.
+- Added: Shuffle & Reverse Methods.
+- Added: Concat Iterators.
 - Added: PriorityQueues

EXTRAS.md

@@ -0,0 +1,41 @@
+### Extra Features
+
+Primitive Collections comes with a few extra features that are disabled by default.    
+These will be enabled as soon they become relevant or never at all.
+
+But some of these can be already unlocked when the target version changes.    
+
+If you compile the library for yourself you will automatically gain access to said features.
+
+### Java17 Exclusive Features    
+Java17 has some new features that can sadly not really be back-ported but the library still supports them if it is compiled with java17
+ 
+- RandomGenerator: Java17 has added [RandomGenerator.class](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/RandomGenerator.html).
+  This allows to use custom random implementations without having to re-implement them yourselves.
+
+
+### ModuleSettings
+Primitive Collections is a huge library.   
+But maybe you only use like 5-10 different classes.   
+Normally you would use tools like "Proguard" to get rid of classes that you don't use.    
+But since a lot of classes have dependencies on each other this would only do so much.    
+
+This is where the [ModuleSettings](ModuleSettings.json) come into play.   
+It allows you to turn of implementations as you wish and adjusts the code that everything still works.   
+
+There is 3 layers of control inside of the ModuleSettings.   
+- Modules directly at the top that turn off everything.   
+- Type Specific configurations, where you can for example turn of everything thats "Long" based.   
+- And then there is each type specific module settings.   
+
+Allowing for greater control without having to edit hundreds of lines of code.   
+On top of that:   
+Any Setting that isn't "Present" is counted as "Enabled".    
+So if you want to disable just 1 thing you can keep that 1 thing and delete the rest of the Setting.    
+It will still work as the same.    
+The default settings just come with everything so you can see what is controllable.   
+
+How to compile the Code with the ModuleSettings enabled:
+```
+/gradlew.bat generateLimitSource build -x test
+```

README.md

@@ -17,6 +17,10 @@ Benchmarks can be found here: [[Charts]](https://github.com/Speiger/Primitive-Co
 [Here](features.md) you find a set of features added to Primitive Collections.   
 These are designed to improve performance or to provide Quality of Life.  
 
+[Here](EXTRAS.md) you also find features that can be used when you compile the library for yourself.    
+These features are not used by default to have a wider range of compat, or require self compilation.    
+Such as pruning classes that are not needed in your code.
+
 ## Main Features:      
 - ArrayLists / LinkedLists / CopyOnWriteLists
 - HashSets/Maps (Linked & HashControl)
@@ -46,7 +50,7 @@ repositories {
     }
 }
 dependencies {
-	implementation 'com.github.Speiger:Primitive-Collections:0.7.0'
+	implementation 'com.github.Speiger:Primitive-Collections:0.9.0'
 }
 ```
 
@@ -71,7 +75,11 @@ Please if you want to contribute follow the [Rule-Sheet](RuleSheet.md). It keeps
 # How to Build
 
 The SourceCode can be generated via:     
+```
 /gradlew.bat generateSource      
+```
 
 to generate SourceCode and build the jar:           
-/gradlew.bat build      
+```
+/gradlew.bat build      
+```

build.gradle

@@ -19,7 +19,7 @@ repositories {
 }
 
 archivesBaseName = 'Primitive Collections'
-version = '0.7.0';
+version = '0.9.0';
 
 sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaVersion.current();
 
@@ -46,7 +46,7 @@ configurations {
 
 dependencies {
 	builderImplementation 'com.google.code.gson:gson:2.10'
-	builderImplementation 'de.speiger:Simple-Code-Generator:1.1.4'
+	builderImplementation 'de.speiger:Simple-Code-Generator:1.3.0'
     testImplementation 'junit:junit:4.12'
     testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
     
@@ -83,14 +83,30 @@ task generateTestSource(type: JavaExec) {
  	args = ['tests', 'silent']
 }
 
+task forceGenerateTestSource(type: JavaExec) {
+	group = 'internal'
+	description = 'Builds the sourcecode for the Tests'
+ 	classpath = sourceSets.builder.runtimeClasspath
+ 	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
+ 	args = ['tests', 'silent', 'force']
+}
+
+task generateLimitSource(type: JavaExec) {
+	group = 'internal'
+	description = 'Builds the Sourcecode with the ModuleSettings.json applied'
+ 	classpath = sourceSets.builder.runtimeClasspath
+ 	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
+ 	args = ['silent', 'load']
+}
+
 task javadocJar(type: Jar) {
     from javadoc
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
 }
 
 task srcJar(type: Jar) {
     from sourceSets.main.allSource
-    classifier = 'sources'
+    archiveClassifier = 'sources'
 }
 
 compileJava.dependsOn generateGithubSource
@@ -113,7 +129,7 @@ task testBooleans(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
 }
 
 task testBytes(type: Test) {
@@ -125,8 +141,8 @@ task testBytes(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
-	maxParallelForks = 2
+	maxParallelForks = testThreads as Integer
 }
 
 task testShorts(type: Test) {
@@ -138,8 +154,8 @@ task testShorts(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
-	maxParallelForks = 2
+	maxParallelForks = testThreads as Integer
 }
 
 task testChars(type: Test) {
@@ -151,8 +167,8 @@ task testChars(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
-	maxParallelForks = 2
+	maxParallelForks = testThreads as Integer
 }
 
 task testInts(type: Test) {
@@ -164,8 +180,8 @@ task testInts(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
-	maxParallelForks = 2
+	maxParallelForks = testThreads as Integer
 }
 
 task testLongs(type: Test) {
@@ -177,8 +193,8 @@ task testLongs(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
-	maxParallelForks = 2
+	maxParallelForks = testThreads as Integer
 }
 
 task testFloats(type: Test) {
@@ -190,8 +206,8 @@ task testFloats(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
-	maxParallelForks = 2
+	maxParallelForks = testThreads as Integer
 }
 
 task testDoubles(type: Test) {
@@ -203,8 +219,8 @@ task testDoubles(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
-	maxParallelForks = 2
+	maxParallelForks = testThreads as Integer
 }
 
 task testObjects(type: Test) {
@@ -216,8 +232,8 @@ task testObjects(type: Test) {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
-	maxParallelForks = 2
+	maxParallelForks = testThreads as Integer
 }
 
 if(System.getProperty("full_test_suite", "false").toBoolean()) {
@@ -240,15 +256,15 @@ test {
 	}
 	useJUnit()
 	ignoreFailures = true
-	maxHeapSize = "1024m"
+	maxHeapSize = maxMemory
 }
 
 jacocoTestReport {
     executionData fileTree(project.buildDir.absolutePath).include("jacoco/*.exec")
     reports {
-        xml.enabled true
+        xml.required = true
-        html.enabled = true
+        html.required = true
-        csv.enabled true
+        csv.required = true
     }
 }
 

gradle.properties

@@ -1 +1,4 @@
-org.gradle.jvmargs=-Xmx3G
+org.gradle.jvmargs=-Xmx3G
+
+maxMemory = 1024m
+testThreads = 2

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
-distributionBase=GRADLE_USER_HOME
+distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
+distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
+zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
+zipStorePath=wrapper/dists

src/builder/java/speiger/src/builder/ClassType.java

@@ -114,7 +114,7 @@ public enum ClassType
 	
 	public boolean needsCustomJDKType()
 	{
-		return this == BYTE || this == SHORT || this == CHAR || this == FLOAT;
+		return this == BOOLEAN || this == BYTE || this == SHORT || this == CHAR || this == FLOAT;
 	}
 	
 	public boolean needsCast()

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

@@ -1,553 +0,0 @@
-package speiger.src.builder;
-
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.function.UnaryOperator;
-
-import speiger.src.builder.mappers.ArgumentMapper;
-import speiger.src.builder.mappers.IMapper;
-import speiger.src.builder.mappers.InjectMapper;
-import speiger.src.builder.mappers.LineMapper;
-import speiger.src.builder.mappers.SimpleMapper;
-import speiger.src.builder.processor.TemplateProcess;
-
-@SuppressWarnings("javadoc")
-public class GlobalVariables
-{
-	List<IMapper> operators = new ArrayList<>();
-	Set<String> flags = new LinkedHashSet<>();
-	ClassType type;
-	ClassType valueType;
-	
-	public GlobalVariables(ClassType type, ClassType subType)
-	{
-		this.type = type;
-		valueType = subType;
-	}
-	
-	public GlobalVariables createVariables()
-	{
-		addSimpleMapper("VALUE_PACKAGE", valueType.getPathType());
-		addSimpleMapper("PACKAGE", type.getPathType());
-		addSimpleMapper("CLASS_TYPE", type.getClassType());
-		addSimpleMapper("CLASS_VALUE_TYPE", valueType.getClassValueType());
-		addSimpleMapper("KEY_TYPE", type.getKeyType());
-		addSimpleMapper("KEY_OBJECT_TYPE", type.isObject() ? "Object" : type.getKeyType());
-		addSimpleMapper("KEY_STRING_TYPE", type.isObject() ? "String" : type.getKeyType());
-		addSimpleMapper("KEY_SPECIAL_TYPE", type.isObject() ? "E" : type.getKeyType());
-		addSimpleMapper("CLASS_OBJECT_TYPE", type.getClassType());
-		addSimpleMapper("CLASS_OBJECT_VALUE_TYPE", valueType.getClassValueType());
-		addSimpleMapper("CLASS_STRING_TYPE", type.isObject() ? "String" : type.getClassType());
-		addSimpleMapper("CLASS_STRING_VALUE_TYPE", valueType.isObject() ? "String" : valueType.getClassValueType());
-		addSimpleMapper("VALUE_TYPE", valueType.getValueType());
-		addSimpleMapper("VALUE_OBJECT_TYPE", valueType.isObject() ? "Object" : valueType.getValueType());
-		addSimpleMapper("VALUE_STRING_TYPE", valueType.isObject() ? "String" : valueType.getValueType());
-		addSimpleMapper("VALUE_SPECIAL_TYPE", valueType.isObject() ? "E" : valueType.getKeyType());
-		addSimpleMapper("KEY_JAVA_TYPE", type.getCustomJDKType().getKeyType());
-		addSimpleMapper("VALUE_JAVA_TYPE", type.getCustomJDKType().getKeyType());
-		
-		addSimpleMapper("EMPTY_KEY_VALUE", type.getEmptyValue());
-		addSimpleMapper("EMPTY_VALUE", valueType.getEmptyValue());
-		
-		addSimpleMapper("INVALID_KEY_VALUE", type.getInvalidValue());
-		addSimpleMapper("INVALID_VALUE", valueType.getInvalidValue());
-		
-		addSimpleMapper(" KEY_STRING_GENERIC_TYPE", type.isObject() ? "<String>" : "");
-		addSimpleMapper(" VALUE_STRING_GENERIC_TYPE", valueType.isObject() ? "<String>" : "");
-		addSimpleMapper(" KEY_VALUE_STRING_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<String, String>" : "<String>") : (valueType.isObject() ? "<String>" : ""));
-
-		
-		addSimpleMapper(" KEY_GENERIC_TYPE", type.isObject() ? "<"+type.getKeyType()+">" : "");
-		addSimpleMapper(" KEY_KEY_GENERIC_TYPE", type.isObject() ? "<"+type.getKeyType()+", "+type.getKeyType()+">" : "");
-		addSimpleMapper(" KEY_CLASS_GENERIC_TYPE", type.isObject() ? "<"+type.getClassType()+">" : "");
-
-		
-		addSimpleMapper(" VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+">" : "");
-		addSimpleMapper(" VALUE_VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : "");
-		addSimpleMapper(" VALUE_CLASS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getClassValueType()+">" : "");
-		
-		addSimpleMapper(" KEY_VALUE_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+", "+valueType.getValueType()+">" : "<"+type.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
-		addSimpleMapper(" KEY_VALUE_VALUE_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+", "+valueType.getValueType()+", "+valueType.getValueType()+">" : "<"+type.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : ""));
-		addInjectMapper(" KEY_VALUE_SPECIAL_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+", "+valueType.getValueType()+", %s>" : "<"+type.getKeyType()+", %s>") : (valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>")).setBraceType("<>").removeBraces();
-		
-		addSimpleMapper(" NO_GENERIC_TYPE", type.isObject() ? "<?>" : "");
-		addSimpleMapper(" NO_KV_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<?, ?>" : "<?>") : valueType.isObject() ? "<?>" : "");
-		addSimpleMapper(" KEY_COMPAREABLE_TYPE", type.isObject() ? "<"+type.getKeyType()+" extends Comparable<T>>" : "");
-		
-		addSimpleMapper(" KEY_SUPER_GENERIC_TYPE", type.isObject() ? "<? super "+type.getKeyType()+">" : "");
-		addSimpleMapper(" VALUE_SUPER_GENERIC_TYPE", valueType.isObject() ? "<? super "+valueType.getValueType()+">" : "");
-		addSimpleMapper(" KEY_VALUE_SUPER_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<? super "+type.getKeyType()+", ? super "+valueType.getValueType()+">" : "<? super "+type.getKeyType()+">") : (valueType.isObject() ? "<? super "+valueType.getValueType()+">" : ""));
-		
-		addSimpleMapper(" KEY_UNKNOWN_GENERIC_TYPE", type.isObject() ? "<? extends "+type.getKeyType()+">" : "");
-		addSimpleMapper(" VALUE_UNKNOWN_GENERIC_TYPE", valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : "");
-		addSimpleMapper(" KEY_VALUE_UNKNOWN_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<? extends "+type.getKeyType()+", ? extends "+valueType.getValueType()+">" : "<? extends "+type.getKeyType()+">") : (valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : ""));
-
-		addSimpleMapper(" KEY_ENUM_VALUE_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">, "+valueType.getValueType()+">" : "<"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">>") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
-		addSimpleMapper(" KEY_VALUE_ENUM_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+", "+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : "<"+type.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : ""));
-		
-		addInjectMapper(" KEY_SPECIAL_GENERIC_TYPE", type.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
-		addInjectMapper(" VALUE_SPECIAL_GENERIC_TYPE", valueType.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
-		addInjectMapper(" KSK_GENERIC_TYPE", type.isObject() ? "<%s, "+type.getKeyType()+">" : "<%s>").removeBraces().setBraceType("<>");
-		addInjectMapper(" KKS_GENERIC_TYPE", type.isObject() ? "<"+type.getKeyType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
-		addArgumentMapper(" KSS_GENERIC_TYPE", type.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
-		addInjectMapper(" VSV_GENERIC_TYPE", valueType.isObject() ? "<%s, "+valueType.getValueType()+">" : "<%s>").removeBraces().setBraceType("<>");
-		addInjectMapper(" VVS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
-		addArgumentMapper(" VSS_GENERIC_TYPE", valueType.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
-
-		addSimpleMapper(" GENERIC_KEY_BRACES", type.isObject() ? " <"+type.getKeyType()+">" : "");
-		addSimpleMapper(" GENERIC_VALUE_BRACES", valueType.isObject() ? " <"+valueType.getValueType()+">" : "");
-		addInjectMapper(" GENERIC_SPECIAL_KEY_BRACES", type.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
-		addInjectMapper(" GENERIC_SPECIAL_VALUE_BRACES", valueType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
-		addSimpleMapper(" GENERIC_KEY_ENUM_VALUE_BRACES", type.isObject() ? (valueType.isObject() ? " <"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">, "+valueType.getValueType()+">" : " <"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">>") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
-		
-		addInjectMapper(" GENERIC_KEY_SPECIAL_BRACES", type.isObject() ? " <"+type.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
-		addInjectMapper(" GENERIC_VALUE_SPECIAL_BRACES", valueType.isObject() ? " <"+valueType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
-		
-		addSimpleMapper(" GENERIC_KEY_VALUE_BRACES", type.isObject() ? (valueType.isObject() ? " <"+type.getKeyType()+", "+valueType.getValueType()+">" : " <"+type.getKeyType()+">") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
-		addSimpleMapper(" COMPAREABLE_KEY_BRACES", type.isObject() ? " <"+type.getKeyType()+" extends Comparable<T>>" : "");
-		addSimpleMapper("KV_BRACES", type.isObject() || valueType.isObject() ? "<>" : "");
-		addSimpleMapper("VALUE_BRACES", valueType.isObject() ? "<>" : "");
-		addSimpleMapper("BRACES", type.isObject() ? "<>" : "");
-		if(type.needsCustomJDKType())
-		{
-			addSimpleMapper("JAVA_TYPE", type.getCustomJDKType().getKeyType());
-			addSimpleMapper("SANITY_CAST", "castTo"+type.getFileType());
-		}
-		addSimpleMapper("JAVA_CLASS", type.getCustomJDKType().getClassType());
-		if(valueType.needsCustomJDKType())
-		{
-			addSimpleMapper("SANITY_CAST_VALUE", "castTo"+valueType.getFileType());
-		}
-		addComment("@ArrayType", "@param <%s> the type of array that the operation should be applied");
-		addComment("@Type", "@param <%s> the type of elements maintained by this Collection");
-		addValueComment("@ValueArrayType", "@param <%s> the type of array that the operation should be applied");
-		addValueComment("@ValueType", "@param <%s> the type of elements maintained by this Collection");
-		addAnnontion("@PrimitiveOverride", "@Override");
-		addSimpleMapper("@PrimitiveDoc", "");
-		addAnnontion("@Primitive", "@Deprecated");
-		addValueAnnontion("@ValuePrimitiveOverride", "@Override");
-		addValueAnnontion("@ValuePrimitive", "@Deprecated");
-		return this;
-	}
-	
-	public GlobalVariables createHelperVariables()
-	{
-		createHelperVars(type, false, "KEY");
-		createHelperVars(valueType, true, "VALUE");
-		return this;
-	}
-	
-	private void createHelperVars(ClassType type, boolean value, String fix)
-	{
-		addArgumentMapper("EQUALS_"+fix+"_TYPE", "Objects.equals(%2$s, "+(type.isObject() ? "%1$s" : fix+"_TO_OBJ(%1$s)")+")").removeBraces();
-		addInjectMapper(fix+"_EQUALS_NOT_NULL", type.getComparableValue()+" != "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
-		addInjectMapper(fix+"_EQUALS_NULL", type.getComparableValue()+" == "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
-		addArgumentMapper(fix+"_EQUALS_NOT", type.getEquals(true)).removeBraces();
-		addArgumentMapper(fix+"_EQUALS", type.getEquals(false)).removeBraces();
-		addSimpleMapper("FILE_"+fix+"_TYPE", type.getFileType());
-		
-		addArgumentMapper("COMPAREABLE_TO_"+fix, type.isObject() ? "((Comparable<"+type.getKeyType(value)+">)%1$s).compareTo(("+type.getKeyType(value)+")%2$s)" : type.getClassType(value)+".compare(%1$s, %2$s)").removeBraces();
-		addArgumentMapper("COMPARE_TO_"+fix, type.isObject() ? "%1$s.compareTo(%2$s)" : type.getClassType(value)+".compare(%1$s, %2$s)").removeBraces();
-		
-		addInjectMapper(fix+"_TO_OBJ", type.isObject() ? "%s" : type.getClassType(value)+".valueOf(%s)").removeBraces();
-		addInjectMapper("OBJ_TO_"+fix, type.isObject() ? "%s" : "%s."+type.getKeyType(value)+"Value()").removeBraces();
-		addInjectMapper("CLASS_TO_"+fix, type.isObject() ? "("+type.getKeyType(value)+")%s" : "(("+type.getClassType(value)+")%s)."+type.getKeyType(value)+"Value()").removeBraces();
-		
-		addInjectMapper(fix+"_TO_HASH", type.isObject() ? "Objects.hashCode(%s)" : type.getClassType(value)+".hashCode(%s)").removeBraces();
-		addInjectMapper(fix+"_TO_STRING", type.isObject() ? "Objects.toString(%s)" : type.getClassType(value)+".toString(%s)").removeBraces();
-		
-		addSimpleMapper("CAST_"+fix+"_ARRAY ", type.isObject() ? "("+fix+"_TYPE[])" : "");
-		addSimpleMapper("EMPTY_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])ARRAYS.EMPTY_ARRAY" : "ARRAYS.EMPTY_ARRAY");
-		addInjectMapper("NEW_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])new Object[%s]" : "new "+fix+"_TYPE[%s]").removeBraces();
-		addInjectMapper("NEW_SPECIAL_"+fix+"_ARRAY", type.isObject() ? "(E[])new Object[%s]" : "new "+fix+"_TYPE[%s]").removeBraces();
-		if(value) addInjectMapper("NEW_CLASS_VALUE_ARRAY", type.isObject() ? "(CLASS_VALUE_TYPE[])new Object[%s]" : "new CLASS_VALUE_TYPE[%s]").removeBraces();
-		else addInjectMapper("NEW_CLASS_ARRAY", type.isObject() ? "(CLASS_TYPE[])new Object[%s]" : "new CLASS_TYPE[%s]").removeBraces();
-	}
-	
-	public GlobalVariables createPreFunctions()
-	{
-		addSimpleMapper("ENTRY_SET", type.getFileType().toLowerCase()+"2"+valueType.getFileType()+"EntrySet");
-		return this;
-	}
-	
-	public GlobalVariables createClassTypes()
-	{
-		addSimpleMapper("JAVA_PREDICATE", type.isPrimitiveBlocking() ? "" : type.getCustomJDKType().getFileType()+"Predicate");
-		addSimpleMapper("JAVA_CONSUMER", type.isPrimitiveBlocking() ? "" : "java.util.function."+type.getCustomJDKType().getFileType()+"Consumer");
-		addSimpleMapper("JAVA_SUPPLIER", type.isPrimitiveBlocking() ? "" : "java.util.function."+type.getCustomJDKType().getFileType()+"Supplier");
-		addSimpleMapper("JAVA_FUNCTION", type.getFunctionClass(valueType));
-		addSimpleMapper("JAVA_BINARY_OPERATOR", type == ClassType.BOOLEAN ? "" : (type.isObject() ? "java.util.function.BinaryOperator" : "java.util.function."+type.getCustomJDKType().getFileType()+"BinaryOperator"));
-		addSimpleMapper("JAVA_UNARY_OPERATOR", type.isObject() ? "BinaryOperator" : type == ClassType.BOOLEAN ? "" : type.getCustomJDKType().getFileType()+"UnaryOperator");
-		addSimpleMapper("JAVA_SPLIT_ITERATOR", type.isPrimitiveBlocking() ? "Spliterator" : "Of"+type.getCustomJDKType().getFileType());
-		addSimpleMapper("JAVA_STREAM", type.isPrimitiveBlocking() ? "" : type.getCustomJDKType().getFileType()+"Stream");
-		addSimpleMapper("JAVA_BUFFER", type.getFileType()+"Buffer");
-		
-		//Final Classes
-		addClassMapper("ARRAY_LIST", "ArrayList");
-		addAbstractMapper("COPY_ON_WRITE_LIST", "CopyOnWrite%sArrayList");
-		addClassMapper("ASYNC_BUILDER", "AsyncBuilder");
-		addClassMapper("LINKED_LIST", "LinkedList");
-		addAbstractMapper("IMMUTABLE_LIST", "Immutable%sList");
-		addClassMapper("ARRAY_FIFO_QUEUE", "ArrayFIFOQueue");
-		addClassMapper("ARRAY_PRIORITY_QUEUE", "ArrayPriorityQueue");
-		addClassMapper("HEAP_PRIORITY_QUEUE", "HeapPriorityQueue");
-		addClassMapper("LINKED_CUSTOM_HASH_SET", "LinkedOpenCustomHashSet");
-		addClassMapper("LINKED_HASH_SET", "LinkedOpenHashSet");
-		addAbstractMapper("IMMUTABLE_HASH_SET", "Immutable%sOpenHashSet");
-		addClassMapper("CUSTOM_HASH_SET", "OpenCustomHashSet");
-		addClassMapper("HASH_SET", "OpenHashSet");
-		addAbstractBiMapper("IMMUTABLE_HASH_MAP", "Immutable%sOpenHashMap", "2");
-		addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
-		addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
-		addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
-		addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
-		addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
-		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
-		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
-		addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
-		addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
-		addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
-		addBiClassMapper("IMMUTABLE_PAIR", "ImmutablePair", "");
-		addBiClassMapper("MUTABLE_PAIR", "MutablePair", "");
-		addClassMapper("RB_TREE_SET", "RBTreeSet");
-		addClassMapper("AVL_TREE_SET", "AVLTreeSet");
-		addClassMapper("ARRAY_SET", "ArraySet");
-		addAbstractBiMapper("SIMPLE_TEST_MAP", "Test%sMap", "2");
-		
-		//Final UnitTest Classes
-		addAbstractMapper("MINIMAL_COLLECTION", "Minimal%sCollection");
-		addAbstractMapper("MINIMAL_SET", "Minimal%sSet");
-		addAbstractMapper("ABSTRACT_CONTAINER_TESTER", "Abstract%sContainerTester");
-		addAbstractMapper("ABSTRACT_COLLECTION_TESTER", "Abstract%sCollectionTester");
-		addAbstractMapper("ABSTRACT_QUEUE_TESTER", "Abstract%sQueueTester");
-		addAbstractMapper("ABSTRACT_LIST_INDEX_OF_TESTER", "Abstract%sListIndexOfTester");
-		addAbstractMapper("ABSTRACT_LIST_TESTER", "Abstract%sListTester");
-		addAbstractMapper("ABSTRACT_SET_TESTER", "Abstract%sSetTester");
-		addAbstractMapper("ABSTRACT_ITERATOR_TESTER", "Abstract%sIteratorTester");
-		addAbstractBiMapper("ABSTRACT_MAP_TESTER", "Abstract%sMapTester", "2");
-		addClassMapper("LIST_ITERATOR_TESTER", "ListIteratorTester");
-		addClassMapper("BIDIRECTIONAL_ITERATOR_TESTER", "BidirectionalteratorTester");
-		addClassMapper("ITERATOR_TESTER", "IteratorTester");
-		addClassMapper("COLLECTION_TEST_BUILDER", "CollectionTestSuiteBuilder");
-		addClassMapper("DEQUEUE_TEST_BUILDER", "DequeueTestSuiteBuilder");
-		addClassMapper("QUEUE_TEST_BUILDER", "QueueTestSuiteBuilder");
-		addClassMapper("LIST_TEST_BUILDER", "ListTestSuiteBuilder");
-		addClassMapper("ORDERED_SET_TEST_BUILDER", "OrderedSetTestSuiteBuilder");
-		addClassMapper("SORTED_SET_TEST_BUILDER", "SortedSetTestSuiteBuilder");
-		addClassMapper("NAVIGABLE_SET_TEST_BUILDER", "NavigableSetTestSuiteBuilder");
-		addClassMapper("SET_TEST_BUILDER", "SetTestSuiteBuilder");
-		addAbstractBiMapper("NAVIGABLE_MAP_TEST_BUILDER", "%sNavigableMapTestSuiteBuilder", "2");
-		addAbstractBiMapper("SORTED_MAP_TEST_BUILDER", "%sSortedMapTestSuiteBuilder", "2");
-		addAbstractBiMapper("ORDERED_MAP_TEST_BUILDER", "%sOrderedMapTestSuiteBuilder", "2");
-		addAbstractBiMapper("MAP_TEST_BUILDER", "%sMapTestSuiteBuilder", "2");
-		addAbstractBiMapper("MAP_CONSTRUCTOR_TESTS", "%sMapConstructorTests", "2");
-		addClassMapper("COLLECTION_CONSTRUCTOR_TESTS", "CollectionConstructorTests");
-		addClassMapper("SUB_SORTED_SET_CLASS_GENERATOR", "SortedSetSubsetTestSetGenerator");
-		addClassMapper("SUB_NAVIGABLE_SET_CLASS_GENERATOR", "NavigableSetSubsetTestSetGenerator");
-		addClassMapper("LIST_TESTS", "ListTests");
-		addClassMapper("SET_TESTS", "SetTests");
-		addClassMapper("QUEUE_TESTS", "QueueTests");
-		addBiClassMapper("MAP_TESTS", "MapTests", "2");
-
-		//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");
-		addClassMapper("SUB_LIST", "SubList");
-		addAbstractMapper("BASE_TASK", "Base%sTask");
-		
-		//Helper Classes
-		addClassMapper("LISTS", "Lists");
-		addClassMapper("SETS", "Sets");
-		addClassMapper("COLLECTIONS", "Collections");
-		addClassMapper("ARRAYS", "Arrays");
-		addClassMapper("PRIORITY_QUEUES", "PriorityQueues");
-		addClassMapper("SPLIT_ITERATORS", "Splititerators");
-		addClassMapper("ITERATORS", "Iterators");
-		addClassMapper("ITERABLES", "Iterables");
-		addBiClassMapper("MAPS", "Maps", "2");
-		addClassMapper("SAMPLE_ELEMENTS", "Samples");
-		
-		//UnitTest Helper Classes
-		addClassMapper("HELPERS", "Helpers");
-		addAbstractMapper("TEST_COLLECTION_GENERATOR", "Test%sCollectionGenerator");
-		addAbstractMapper("TEST_QUEUE_GENERATOR", "Test%sQueueGenerator");
-		addAbstractMapper("TEST_LIST_GENERATOR", "Test%sListGenerator");
-		addAbstractMapper("TEST_NAVIGABLE_SET_GENERATOR", "Test%sNavigableSetGenerator");
-		addAbstractMapper("TEST_SORTED_SET_GENERATOR", "Test%sSortedSetGenerator");
-		addAbstractMapper("TEST_ORDERED_SET_GENERATOR", "Test%sOrderedSetGenerator");
-		addAbstractMapper("TEST_SET_GENERATOR", "Test%sSetGenerator");
-		addAbstractMapper("SIMPLE_TEST_GENERATOR", "Simple%sTestGenerator");
-		addAbstractMapper("SIMPLE_QUEUE_TEST_GENERATOR", "Simple%sQueueTestGenerator");
-		addAbstractBiMapper("SIMPLE_MAP_TEST_GENERATOR", "Simple%sMapTestGenerator", "2");
-		addAbstractBiMapper("DERIVED_MAP_GENERATORS", "Derived%sMapGenerators", "2");
-		addAbstractBiMapper("TEST_ORDERED_MAP_GENERATOR", "Test%sOrderedMapGenerator", "2");
-		addAbstractBiMapper("TEST_SORTED_MAP_GENERATOR", "Test%sSortedMapGenerator", "2");
-		addAbstractBiMapper("TEST_MAP_GENERATOR", "Test%sMapGenerator", "2");
-		
-		//Interfaces
-		addClassMapper("LIST_ITERATOR", "ListIterator");
-		addClassMapper("BI_ITERATOR", "BidirectionalIterator");
-		addBiClassMapper("BI_CONSUMER", "Consumer", "");
-		addClassMapper("BI_TO_OBJECT_CONSUMER", "ObjectConsumer");
-		addAbstractMapper("BI_FROM_OBJECT_CONSUMER", "Object%sConsumer");
-		addClassMapper("SPLIT_ITERATOR", "Splititerator");
-		addClassMapper("ITERATOR", "Iterator");
-		addClassMapper("ITERABLE", "Iterable");
-		addClassMapper("COLLECTION", "Collection");
-		addClassMapper("TO_OBJECT_FUNCTION", "2ObjectFunction");
-		addBiClassMapper("FUNCTION", "Function", "2");
-		addClassMapper("LIST_ITER", "ListIter");
-		addClassMapper("LIST", "List");
-		addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
-		addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
-		addBiClassMapper("SORTED_MAP", "SortedMap", "2");
-		addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
-		addBiClassMapper("MAP", "Map", "2");
-		addClassMapper("NAVIGABLE_SET", "NavigableSet");
-		addBiClassMapper("PAIR", "Pair", "");
-		addClassMapper("PRIORITY_QUEUE", "PriorityQueue");
-		addClassMapper("PRIORITY_DEQUEUE", "PriorityDequeue");
-		addClassMapper("PREDICATE", "2BooleanFunction");
-		addClassMapper("SORTED_SET", "SortedSet");
-		addClassMapper("ORDERED_SET", "OrderedSet");
-		addClassMapper("SET", "Set");
-		addClassMapper("STRATEGY", "Strategy");
-		addClassMapper("STACK", "Stack");
-		addClassMapper("SUPPLIER", "Supplier");
-		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
-		addClassMapper("TASK", "Task");
-		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");
-		if(type.isObject())
-		{
-			if(!valueType.isObject()) addSimpleMapper("VALUE_CONSUMER", valueType.getFileType()+"Consumer");
-			else addSimpleMapper("VALUE_CONSUMER", "Consumer");
-			addSimpleMapper("CONSUMER", "Consumer");
-			addSimpleMapper("IARRAY", "IObjectArray");
-		}
-		else
-		{
-			if(valueType.isObject()) 
-			{
-				addSimpleMapper("VALUE_CONSUMER", "Consumer");
-				addSimpleMapper("CONSUMER", type.getFileType()+"Consumer");
-			}
-			else addClassMapper("CONSUMER", "Consumer");
-			addFunctionMappers("IARRAY", "I%sArray");
-		}
-		addSimpleMapper("VALUE_COMPARATOR", valueType.isObject() ? "Comparator" : String.format("%sComparator", valueType.getNonFileType()));
-		addSimpleMapper("COMPARATOR", type.isObject() ? "Comparator" : String.format("%sComparator", type.getNonFileType()));
-		return this;
-	}
-	
-	public GlobalVariables createFunctions()
-	{
-		addSimpleMapper("APPLY_KEY_VALUE", type.isObject() ? "apply" : "applyAs"+type.getNonFileType());
-		addSimpleMapper("APPLY_VALUE", valueType.isObject() ? "apply" : "applyAs"+valueType.getNonFileType());
-		addSimpleMapper("APPLY_CAST", "applyAs"+type.getCustomJDKType().getNonFileType());
-		addSimpleMapper("APPLY", type.isObject() ? "apply" : "applyAs"+type.getNonFileType());
-		addFunctionValueMapper("BULK_MERGE", "mergeAll");
-		addFunctionValueMappers("COMPUTE_IF_ABSENT", "compute%sIfAbsent");
-		addFunctionValueMappers("COMPUTE_IF_PRESENT", "compute%sIfPresent");
-		addFunctionValueMapper("COMPUTE", "compute");
-		addFunctionMapper("DEQUEUE_LAST", "dequeueLast");
-		addFunctionMapper("DEQUEUE", "dequeue");
-		addFunctionMappers("POLL_FIRST_ENTRY_KEY", "pollFirst%sKey");
-		addFunctionMappers("POLL_LAST_ENTRY_KEY", "pollLast%sKey");
-		addFunctionMapper("POLL_FIRST_KEY", "pollFirst");
-		addFunctionMapper("POLL_LAST_KEY", "pollLast");
-		addFunctionMappers("FIRST_ENTRY_KEY", "first%sKey");
-		addFunctionValueMappers("FIRST_ENTRY_VALUE", "first%sValue");
-		addFunctionMapper("FIRST_KEY", "first");
-		addFunctionMappers("LAST_ENTRY_KEY", "last%sKey");
-		addFunctionValueMappers("LAST_ENTRY_VALUE", "last%sValue");
-		addFunctionMappers("ENTRY_KEY", "get%sKey");
-		addFunctionValueMappers("ENTRY_VALUE", "get%sValue");
-		addFunctionMappers("KEY_ENTRY", "set%sKey");
-		addFunctionValueMappers("VALUE_ENTRY", "set%sValue");
-		addFunctionMapper("GET_KEY", "get");
-		if(type.isObject()) addFunctionValueMapper("GET_VALUE", valueType.isObject() ? "getObject" : "get");
-		else addSimpleMapper("GET_VALUE", "get");
-		addSimpleMapper("GET_JAVA", type.isObject() ? "get" : "getAs"+type.getCustomJDKType().getNonFileType());
-		addFunctionMapper("LAST_KEY", "last");
-		addFunctionValueMapper("MERGE", "merge");
-		addFunctionMapper("NEXT", "next");
-		addFunctionMapper("PREVIOUS", "previous");
-		addFunctionMapper("REMOVE_SWAP", "swapRemove");
-		if(type.isObject()) addFunctionMapper("REMOVE_VALUE", "rem");
-		else addSimpleMapper("REMOVE_VALUE", "remove");
-		addFunctionMapper("REMOVE_KEY", "rem");
-		addFunctionMapper("REMOVE_LAST", "removeLast");
-		addFunctionMapper("REMOVE", "remove");
-		addFunctionValueMappers("REPLACE_VALUES", valueType.isObject() ? "replaceObjects" : "replace%ss");
-		addFunctionMappers("REPLACE", type.isObject() ? "replaceObjects" : "replace%ss");
-		addFunctionMappers("SORT", "sort%ss");
-		addFunctionValueMappers("SUPPLY_IF_ABSENT", "supply%sIfAbsent");
-		addSimpleMapper("VALUE_TEST_VALUE", valueType.isObject() ? "getBoolean" : "get");
-		addSimpleMapper("TEST_VALUE", type.isObject() ? "getBoolean" : "get");
-		addSimpleMapper("NEW_STREAM", type.isPrimitiveBlocking() ? "" : type.getCustomJDKType().getKeyType()+"Stream");
-		addSimpleMapper("VALUE_TO_ARRAY", "to"+valueType.getNonFileType()+"Array");
-		addSimpleMapper("TO_ARRAY", "to"+type.getNonFileType()+"Array");
-		addSimpleMapper("[SPACE]", " ");
-		operators.sort(Comparator.comparing(IMapper::getSearchValue, this::sort));
-		return this;
-	}
-	
-	public GlobalVariables createFlags()
-	{
-		flags.add("TYPE_"+type.getCapType());
-		flags.add("VALUE_"+valueType.getCapType());
-		if(type == valueType) flags.add("SAME_TYPE");
-		if(type.hasFunction(valueType)) flags.add("JDK_FUNCTION");
-		if(!type.needsCustomJDKType()) flags.add("JDK_TYPE");
-		if(!type.isPrimitiveBlocking()) flags.add("PRIMITIVES");
-		if(!valueType.isPrimitiveBlocking()) flags.add("VALUE_PRIMITIVES");
-		if(valueType.needsCustomJDKType()) flags.add("JDK_VALUE");
-		return this;
-	}
-	
-	public TemplateProcess create(String fileName, String splitter, boolean valueOnly)
-	{
-		TemplateProcess process = new TemplateProcess(String.format(fileName+".java", (splitter != null ? type.getFileType()+splitter+valueType.getFileType() : (valueOnly ? valueType : type).getFileType())));
-		process.setPathBuilder(new PathBuilder(type.getPathType()));
-		process.addFlags(flags);
-		process.addMappers(operators);
-		return process;
-	}
-	
-	public void testComparason(List<String> keys, List<String> values) {
-		List<IMapper> copy = new ArrayList<>(operators);
-		Collections.shuffle(copy);
-		copy.sort(Comparator.comparing(IMapper::getSearchValue, this::sort));
-		operators.stream().map(IMapper::getSearchValue).forEach(keys::add);
-		copy.stream().map(IMapper::getSearchValue).forEach(values::add);
-	}
-	
-	private int sort(String key, String value) {
-		if(value.contains(key)) return 1;
-		else if(key.contains(value)) return -1;
-		return 0;
-	}
-	
-	public ClassType getType()
-	{
-		return type;
-	}
-	
-	private void addClassMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, valueType.getFileType()+replacement));
-		operators.add(new SimpleMapper(pattern, pattern, type.getFileType()+replacement));
-	}
-	
-	private void addBiClassMapper(String pattern, String replacement, String splitter)
-	{
-		operators.add(new SimpleMapper("KEY_"+pattern, "KEY_"+pattern, type.getFileType()+splitter+type.getFileType()+replacement));
-		operators.add(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, valueType.getFileType()+splitter+valueType.getFileType()+replacement));
-		operators.add(new SimpleMapper(pattern, pattern, type.getFileType()+splitter+valueType.getFileType()+replacement));
-	}
-	
-	private void addAbstractMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, String.format(replacement, valueType.getFileType())));
-		operators.add(new SimpleMapper(pattern, pattern, String.format(replacement, type.getFileType())));		
-	}
-	
-	private void addAbstractBiMapper(String pattern, String replacement, String splitter) 
-	{
-		operators.add(new SimpleMapper(pattern, pattern, String.format(replacement, type.getFileType()+splitter+valueType.getFileType())));
-	}
-	
-	private void addFunctionMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, replacement+valueType.getNonFileType()));
-		operators.add(new SimpleMapper(pattern, pattern, replacement+type.getNonFileType()));
-	}
-	
-	private void addFunctionValueMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(pattern, pattern, replacement+valueType.getNonFileType()));
-	}
-	
-	private void addFunctionMappers(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, String.format(replacement, valueType.getNonFileType())));		
-		operators.add(new SimpleMapper(pattern, pattern, String.format(replacement, type.getNonFileType())));		
-	}
-	
-	private void addFunctionValueMappers(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(pattern, pattern, String.format(replacement, valueType.getNonFileType())));		
-	}
-	
-	private void addSimpleMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(pattern, pattern, replacement));
-	}
-	
-	private void addAnnontion(String pattern, String value)
-	{
-		if(type == ClassType.OBJECT) operators.add(new LineMapper(pattern, pattern));
-		else operators.add(new SimpleMapper(pattern, pattern, value));
-	}
-	
-	private void addValueAnnontion(String pattern, String value)
-	{
-		if(valueType == ClassType.OBJECT) operators.add(new LineMapper(pattern, pattern));
-		else operators.add(new SimpleMapper(pattern, pattern, value));
-	}
-	
-	private void addComment(String pattern, String value)
-	{
-		if(type == ClassType.OBJECT) operators.add(new InjectMapper(pattern, pattern, value).removeBraces());
-		else operators.add(new LineMapper(pattern, pattern));
-	}
-	
-	private void addValueComment(String pattern, String value)
-	{
-		if(valueType == ClassType.OBJECT) operators.add(new InjectMapper(pattern, pattern, value).removeBraces());
-		else operators.add(new LineMapper(pattern, pattern));
-	}
-	
-	private InjectMapper addInjectMapper(String pattern, String replacement)
-	{
-		InjectMapper mapper = new InjectMapper(pattern, pattern, replacement);
-		operators.add(mapper);
-		return mapper;
-	}
-	
-	private ArgumentMapper addArgumentMapper(String pattern, String replacement)
-	{
-		return addArgumentMapper(pattern, replacement, ", ");
-	}
-	
-	private ArgumentMapper addArgumentMapper(String pattern, String replacement, String splitter)
-	{
-		ArgumentMapper mapper = new ArgumentMapper(pattern, pattern, replacement, splitter);
-		operators.add(mapper);
-		return mapper;
-	}
-	
-	class PathBuilder implements UnaryOperator<Path>
-	{
-		String before;
-		
-		public PathBuilder(String before)
-		{
-			this.before = before;
-		}
-		
-		@Override
-		public Path apply(Path t)
-		{
-			return t.subpath(0, 6).resolve(before).resolve(t.subpath(6, t.getNameCount()));
-		}
-	}
-}

src/builder/java/speiger/src/builder/ModulePackage.java

@@ -1,149 +1,155 @@
-package speiger.src.builder;
+package speiger.src.builder;
-
+
-import java.nio.file.Path;
+import java.nio.file.Path;
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Arrays;
-import java.util.Comparator;
+import java.util.Comparator;
-import java.util.HashMap;
+import java.util.HashMap;
-import java.util.HashSet;
+import java.util.HashSet;
-import java.util.LinkedHashSet;
+import java.util.LinkedHashSet;
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-import java.util.Set;
+import java.util.Set;
-import java.util.function.BiConsumer;
+import java.util.function.BiConsumer;
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-import java.util.function.Predicate;
+import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
+import java.util.function.UnaryOperator;
-
+
-import speiger.src.builder.mappers.IMapper;
+import speiger.src.builder.mappers.IMapper;
-import speiger.src.builder.processor.TemplateProcess;
+import speiger.src.builder.processor.TemplateProcess;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class ModulePackage
+public class ModulePackage
-{
+{
-	private static final BiConsumer<String, RequiredType> VOID = (K, V) -> {};
+	private static final BiConsumer<String, RequiredType> VOID = (K, V) -> {};
-	public static final ClassType[] TYPE = ClassType.values();
+	public static final ClassType[] TYPE = ClassType.values();
-	final ClassType keyType;
+	final ClassType keyType;
-	final ClassType valueType;
+	final ClassType valueType;
-	Set<String> blocked = new HashSet<>();
+	Set<String> blocked = new HashSet<>();
-	Map<String, String> nameRemapper = new HashMap<>();
+	Map<String, String> nameRemapper = new HashMap<>();
-	Map<String, String> splitters = new HashMap<>();
+	Map<String, String> splitters = new HashMap<>();
-	List<Predicate<String>> blockedFilters = new ArrayList<>();
+	List<Predicate<String>> blockedFilters = new ArrayList<>();
-	List<IMapper> mappers = new ArrayList<>();
+	List<IMapper> mappers = new ArrayList<>();
-	Set<String> flags = new LinkedHashSet<>();
+	Set<String> flags = new LinkedHashSet<>();
-	Set<String> globalFlags;
+	Set<String> globalFlags;
-	BiConsumer<String, RequiredType> requirements = VOID;
+	Map<String, Integer> flaggedValues = new HashMap<>();
-	
+	BiConsumer<String, RequiredType> requirements = VOID;
-	public ModulePackage(Set<String> globalFlags, ClassType keyType, ClassType valueType) {
+	
-		this.globalFlags = globalFlags;
+	public ModulePackage(Set<String> globalFlags, ClassType keyType, ClassType valueType) {
-		this.keyType = keyType;
+		this.globalFlags = globalFlags;
-		this.valueType = valueType;
+		this.keyType = keyType;
-	}
+		this.valueType = valueType;
-	
+	}
-	public void finish() {
+	
-		requirements = VOID;
+	public void finish() {
-		mappers.sort(Comparator.comparing(IMapper::getSearchValue, Comparator.comparingInt(String::length).reversed()));
+		requirements = VOID;
-		mappers.sort(Comparator.comparing(IMapper::getSearchValue, this::sort));
+		mappers.sort(Comparator.comparing(IMapper::getSearchValue, Comparator.comparingInt(String::length).reversed()));
-	}
+		mappers.sort(Comparator.comparing(IMapper::getSearchValue, this::sort));
-	
+	}
-	public void setRequirements(BiConsumer<String, RequiredType> requirements) {
+	
-		this.requirements = requirements;
+	public void setRequirements(BiConsumer<String, RequiredType> requirements) {
-	}
+		this.requirements = requirements;
-	
+	}
-	public boolean isSame() {
+	
-		return keyType == valueType;
+	public boolean isSame() {
-	}
+		return keyType == valueType;
-	
+	}
-	public boolean isEnumValid() {
+	
-		return keyType == ClassType.OBJECT;
+	public boolean isEnumValid() {
-	}
+		return keyType == ClassType.OBJECT;
-	
+	}
-	public ClassType getKeyType() {
+	
-		return keyType;
+	public ClassType getKeyType() {
-	}
+		return keyType;
-	
+	}
-	public ClassType getValueType() {
+	
-		return valueType;
+	public ClassType getValueType() {
-	}
+		return valueType;
-	
+	}
-	public void addFlag(String flag) {
+	
-		flags.add(flag);
+	public void addFlag(String flag) {
-	}
+		flags.add(flag);
-	
+	}
-	public void addGlobalFlag(String flag) {
+	
-		globalFlags.add(flag);
+	public void addGlobalFlag(String flag) {
-	}
+		globalFlags.add(flag);
-	
+	}
-	public void addRequirement(String fileName, RequiredType type) {
+	
-		requirements.accept(fileName, type);
+	public void addValue(String key, int value) {
-	}
+		flaggedValues.put(key, value);
-	
+	}
-	public void addMapper(IMapper mapper) {
+	
-		mappers.add(mapper);
+	public void addRequirement(String fileName, RequiredType type) {
-	}
+		requirements.accept(fileName, type);
-	
+	}
-	public void addBlockedFilter(Predicate<String> filter) {
+	
-		blockedFilters.add(filter);
+	public void addMapper(IMapper mapper) {
-	}
+		mappers.add(mapper);
-	
+	}
-	public void addBlockedFiles(String... names) {
+	
-		blocked.addAll(Arrays.asList(names));
+	public void addBlockedFilter(Predicate<String> filter) {
-	}
+		blockedFilters.add(filter);
-	
+	}
-	public void addSplitter(String fileName, String splitter) {
+	
-		splitters.put(fileName, splitter);
+	public void addBlockedFiles(String... names) {
-	}
+		blocked.addAll(Arrays.asList(names));
-	
+	}
-	public void addRemapper(String fileName, String actualName) {
+	
-		nameRemapper.put(fileName, actualName);
+	public void addSplitter(String fileName, String splitter) {
-	}
+		splitters.put(fileName, splitter);
-	
+	}
-	public void process(String fileName, Consumer<TemplateProcess> result) {
+	
-		if(isBlocked(fileName)) return;
+	public void addRemapper(String fileName, String actualName) {
-		String splitter = String.format(splitters.getOrDefault(fileName, keyType.getFileType()), keyType.getFileType(), valueType.getFileType());
+		nameRemapper.put(fileName, actualName);
-		String newName = String.format(nameRemapper.getOrDefault(fileName, "%s"+fileName), splitter);
+	}
-		TemplateProcess process = new TemplateProcess(newName+".java");
+	
-		process.setPathBuilder(new PathBuilder(keyType.getPathType()));
+	public void process(String fileName, Consumer<TemplateProcess> result) {
-		process.addFlags(flags);
+		if(isBlocked(fileName)) return;
-		process.addFlags(globalFlags);
+		String splitter = String.format(splitters.getOrDefault(fileName, keyType.getFileType()), keyType.getFileType(), valueType.getFileType());
-		process.addMappers(mappers);
+		String newName = String.format(nameRemapper.getOrDefault(fileName, "%s"+fileName), splitter);
-		result.accept(process);
+		TemplateProcess process = new TemplateProcess(newName+".java");
-	}
+		process.setPathBuilder(new PathBuilder(keyType.getPathType()));
-	
+		process.addFlags(flags);
-	private boolean isBlocked(String fileName) {
+		process.addFlags(globalFlags);
-		if(blocked.contains(fileName)) return true;
+		process.addMappers(mappers);
-		for(int i = 0,m=blockedFilters.size();i<m;i++) {
+		process.addValues(flaggedValues);
-			if(blockedFilters.get(i).test(fileName)) return true;
+		result.accept(process);
-		}
+	}
-		return false;
+	
-	}
+	private boolean isBlocked(String fileName) {
-	
+		if(blocked.contains(fileName)) return true;
-	public static List<ModulePackage> createPackages(Set<String> globalFlags) {
+		for(int i = 0,m=blockedFilters.size();i<m;i++) {
-		List<ModulePackage> list = new ArrayList<>();
+			if(blockedFilters.get(i).test(fileName)) return true;
-		for(ClassType key : TYPE) {
+		}
-			for(ClassType value : TYPE) {
+		return false;
-				list.add(new ModulePackage(globalFlags, key, value));
+	}
-			}
+	
-		}
+	public static List<ModulePackage> createPackages(Set<String> globalFlags) {
-		return list;
+		List<ModulePackage> list = new ArrayList<>();
-	}
+		for(ClassType key : TYPE) {
-	
+			for(ClassType value : TYPE) {
-	private int sort(String key, String value) {
+				list.add(new ModulePackage(globalFlags, key, value));
-		if(value.contains(key)) return 1;
+			}
-		else if(key.contains(value)) return -1;
+		}
-		return 0;
+		return list;
-	}
+	}
-	
+	
-	class PathBuilder implements UnaryOperator<Path> {
+	private int sort(String key, String value) {
-		String before;
+		if(value.contains(key)) return 1;
-		
+		else if(key.contains(value)) return -1;
-		public PathBuilder(String before) {
+		return 0;
-			this.before = before;
+	}
-		}
+	
-		
+	class PathBuilder implements UnaryOperator<Path> {
-		@Override
+		String before;
-		public Path apply(Path t) {
+		
-			return t.subpath(0, 6).resolve(before).resolve(t.subpath(6, t.getNameCount()));
+		public PathBuilder(String before) {
-		}
+			this.before = before;
-	}
+		}
-}
+		
+		@Override
+		public Path apply(Path t) {
+			return t.subpath(0, 6).resolve(before).resolve(t.subpath(6, t.getNameCount()));
+		}
+	}
+}

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

@@ -1,270 +1,229 @@
-package speiger.src.builder;
+package speiger.src.builder;
-
+
-import java.io.BufferedWriter;
+import java.io.BufferedWriter;
-import java.io.IOException;
+import java.io.IOException;
-import java.nio.file.Files;
+import java.nio.file.Files;
-import java.nio.file.Path;
+import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.nio.file.Paths;
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Arrays;
-import java.util.Collections;
+import java.util.Collections;
-import java.util.HashMap;
+import java.util.HashMap;
-import java.util.HashSet;
+import java.util.HashSet;
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-import java.util.Set;
+import java.util.Set;
-import java.util.StringJoiner;
+import java.util.StringJoiner;
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-import java.util.stream.Stream;
+import java.util.stream.Stream;
-
+
-import speiger.src.builder.modules.AsyncModule;
+import speiger.src.builder.modules.AsyncModule;
-import speiger.src.builder.modules.BaseModule;
+import speiger.src.builder.modules.BaseModule;
-import speiger.src.builder.modules.CollectionModule;
+import speiger.src.builder.modules.CollectionModule;
-import speiger.src.builder.modules.FunctionModule;
+import speiger.src.builder.modules.FunctionModule;
-import speiger.src.builder.modules.JavaModule;
+import speiger.src.builder.modules.JavaModule;
-import speiger.src.builder.modules.ListModule;
+import speiger.src.builder.modules.ListModule;
-import speiger.src.builder.modules.MapModule;
+import speiger.src.builder.modules.MapModule;
-import speiger.src.builder.modules.PairModule;
+import speiger.src.builder.modules.PairModule;
-import speiger.src.builder.modules.PrioQueueModule;
+import speiger.src.builder.modules.PrioQueueModule;
-import speiger.src.builder.modules.SetModule;
+import speiger.src.builder.modules.SetModule;
-import speiger.src.builder.processor.TemplateProcess;
+import speiger.src.builder.processor.TemplateProcess;
-import speiger.src.builder.processor.TemplateProcessor;
+import speiger.src.builder.processor.TemplateProcessor;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class PrimitiveCollectionsBuilder extends TemplateProcessor
+public class PrimitiveCollectionsBuilder extends TemplateProcessor
-{
+{
-	private static final int SPECIAL = 0x1; //Detects if the Builder is generating tests
+	private static final int SPECIAL = 0x1; //Detects if the Builder is generating tests
-	private static final int LOAD = 0x2; //If Configs should be loaded
+	private static final int LOAD = 0x2; //If Configs should be loaded
-	private static final int ANTI_SAVE = SPECIAL | LOAD; //If save should be disabled since load/save shouldn't happen at the same time.
+	private static final int ANTI_SAVE = SPECIAL | LOAD; //If save should be disabled since load/save shouldn't happen at the same time.
-	private static final int SAVE = 0x4; //if the configuration should be created
+	private static final int SAVE = 0x4; //if the configuration should be created
-	Set<String> globalFlags = new HashSet<>();
+	Set<String> globalFlags = new HashSet<>();
-	List<ModulePackage> simplePackages = new ArrayList<>();
+	List<ModulePackage> simplePackages = new ArrayList<>();
-	List<ModulePackage> biPackages = new ArrayList<>();
+	List<ModulePackage> biPackages = new ArrayList<>();
-	List<ModulePackage> enumPackages = new ArrayList<>();
+	List<ModulePackage> enumPackages = new ArrayList<>();
-	Map<String, RequiredType> requirements = new HashMap<>();
+	Map<String, RequiredType> requirements = new HashMap<>();
-	SettingsManager manager = new SettingsManager();
+	SettingsManager manager = new SettingsManager();
-	int flags;
+	int flags;
-	
+	
-	public PrimitiveCollectionsBuilder()
+	public PrimitiveCollectionsBuilder() {
-	{
+		this(false);
-		this(false);
+	}
-	}
+	
-	
+	public PrimitiveCollectionsBuilder(boolean silencedSuccess) {
-	public PrimitiveCollectionsBuilder(boolean silencedSuccess)
+		super(silencedSuccess, Paths.get("src/builder/resources/speiger/assets/collections/templates/"), Paths.get("src/main/java/speiger/src/collections/"), Paths.get("src/builder/resources/speiger/assets/collections/"));
-	{
+	}
-		super(silencedSuccess, Paths.get("src/builder/resources/speiger/assets/collections/templates/"), Paths.get("src/main/java/speiger/src/collections/"), Paths.get("src/builder/resources/speiger/assets/collections/"));
+	
-	}
+	public PrimitiveCollectionsBuilder(Path sourceFolder, Path outputFolder, Path dataFolder) {
-	
+		this(false, sourceFolder, outputFolder, dataFolder);
-	public PrimitiveCollectionsBuilder(Path sourceFolder, Path outputFolder, Path dataFolder)
+	}
-	{
+	
-		this(false, sourceFolder, outputFolder, dataFolder);
+	public PrimitiveCollectionsBuilder(boolean silencedSuccess, Path sourceFolder, Path outputFolder, Path dataFolder) {
-	}
+		super(silencedSuccess, sourceFolder, outputFolder, dataFolder);
-	
+	}
-	public PrimitiveCollectionsBuilder(boolean silencedSuccess, Path sourceFolder, Path outputFolder, Path dataFolder)
+	
-	{
+	private PrimitiveCollectionsBuilder setFlags(int flags) {
-		super(silencedSuccess, sourceFolder, outputFolder, dataFolder);
+		this.flags = flags;
-	}
+		if((flags & ANTI_SAVE) != 0) {
-	
+			this.flags &= ~SAVE;
-	private PrimitiveCollectionsBuilder setFlags(int flags) {
+		}
-		this.flags = flags;
+		return this;
-		if((flags & ANTI_SAVE) != 0) {
+	}
-			this.flags &= ~SAVE;
+	
-		}
+	private static PrimitiveCollectionsBuilder createTests(boolean silent, int flags) {
-		return this;
+		return new PrimitiveCollectionsBuilder(silent, 
-	}
+				Paths.get("src/builder/resources/speiger/assets/tests/templates/"), 
-	
+				Paths.get("src/test/java/speiger/src/tests/"), 
-	private static PrimitiveCollectionsBuilder createTests(boolean silent, int flags) {
+				Paths.get("src/builder/resources/speiger/assets/tests/")).setFlags(flags | SPECIAL);
-		return new PrimitiveCollectionsBuilder(silent, 
+	}
-				Paths.get("src/builder/resources/speiger/assets/tests/templates/"), 
+	
-				Paths.get("src/test/java/speiger/src/tests/"), 
+	private static PrimitiveCollectionsBuilder createTesters(boolean silent, int flags) {
-				Paths.get("src/builder/resources/speiger/assets/tests/")).setFlags(flags | SPECIAL);
+		return new PrimitiveCollectionsBuilder(silent, 
-	}
+				Paths.get("src/builder/resources/speiger/assets/testers/templates/"), 
-	
+				Paths.get("src/test/java/speiger/src/testers/"), 
-	private static PrimitiveCollectionsBuilder createTesters(boolean silent, int flags) {
+				Paths.get("src/builder/resources/speiger/assets/testers/")).setFlags(flags | SPECIAL);
-		return new PrimitiveCollectionsBuilder(silent, 
+	}
-				Paths.get("src/builder/resources/speiger/assets/testers/templates/"), 
+	
-				Paths.get("src/test/java/speiger/src/testers/"), 
+	@Override
-				Paths.get("src/builder/resources/speiger/assets/testers/")).setFlags(flags | SPECIAL);
+	protected boolean isFileValid(Path fileName) { return true; }
-	}
+	@Override
-	
+	protected boolean relativePackages() { return true; }
-	@Override
+	@Override
-	protected boolean isFileValid(Path fileName)
+	protected boolean debugUnusedMappers() { return false; }
-	{
+	
-		return true;
+	@Override
-	}
+	protected void afterFinish() {
-	
+		if((flags & SPECIAL) == 0 && getVersion() > 8)  {
-	@Override
+			Path basePath = Paths.get("src/main/java");
-	protected boolean relativePackages()
+			try(BufferedWriter writer = Files.newBufferedWriter(basePath.resolve("module-info.java"))) {
-	{
+				writer.write(getModuleInfo(basePath));
-		return true;
+			}
-	}
+			catch(Exception e) { e.printStackTrace(); }
-	
+		}
-	@Override
+	}
-	protected boolean debugUnusedMappers()
+	
-	{
+	public List<BaseModule> createModules() {
-		return false;
+		List<BaseModule> modules = new ArrayList<>();
-	}
+		modules.add(JavaModule.INSTANCE);
-	
+		modules.add(FunctionModule.INSTANCE);
-	@Override
+		modules.add(CollectionModule.INSTANCE);
-	protected void afterFinish()
+		modules.add(PrioQueueModule.INSTANCE);
-	{
+		modules.add(ListModule.INSTANCE);
-		if((flags & SPECIAL) == 0 && getVersion() > 8) 
+		modules.add(SetModule.INSTANCE);
-		{
+		modules.add(MapModule.INSTANCE);
-			Path basePath = Paths.get("src/main/java");
+		modules.add(PairModule.INSTANCE);
-			try(BufferedWriter writer = Files.newBufferedWriter(basePath.resolve("module-info.java")))
+		modules.add(AsyncModule.INSTANCE);
-			{
+		return modules;
-				writer.write(getModuleInfo(basePath));
+	}
-			}
+
-			catch(Exception e)
+	
-			{
+	@Override
-				e.printStackTrace();
+	protected void init()  {
-			}
+		prepPackages();
-		}
+		//Init Modules here
-	}
+		addModules(createModules());
-	
+		finishPackages();
-	public List<BaseModule> createModules()
+	}
-	{
+	
-		List<BaseModule> modules = new ArrayList<>();
+	public void addModules(List<BaseModule> modules) {
-		modules.add(JavaModule.INSTANCE);
+		for(int i = 0,m=modules.size();i<m;i++) {
-		modules.add(FunctionModule.INSTANCE);
+			modules.get(i).setManager(manager);
-		modules.add(CollectionModule.INSTANCE);
+		}
-		modules.add(PrioQueueModule.INSTANCE);
+		for(int i = 0,m=modules.size();i<m;i++) {
-		modules.add(ListModule.INSTANCE);
+			biPackages.forEach(modules.get(i)::init);
-		modules.add(SetModule.INSTANCE);
+		}
-		modules.add(MapModule.INSTANCE);
+		modules.forEach(BaseModule::cleanup);
-		modules.add(PairModule.INSTANCE);
+	}
-		modules.add(AsyncModule.INSTANCE);
+	
-		return modules;
+	private void finishPackages()  {
-	}
+		biPackages.forEach(ModulePackage::finish);
-
+		if((flags & SAVE) != 0) manager.save();
-	
+	}
-	@Override
+	
-	protected void init() 
+	private void prepPackages() {
-	{
+		if((flags & LOAD) != 0) manager.load();
-		prepPackages();
+		for(ModulePackage entry : ModulePackage.createPackages(globalFlags)) {
-		//Init Modules here
+			entry.setRequirements(requirements::put);
-		addModules(createModules());
+			biPackages.add(entry);
-		finishPackages();
+			if(entry.isSame()) simplePackages.add(entry);
-	}
+			if(entry.isEnumValid()) enumPackages.add(entry);
-	
+		}		
-	public void addModules(List<BaseModule> modules)
+	}
-	{
+	
-		for(int i = 0,m=modules.size();i<m;i++) {
+	@Override
-			modules.get(i).setManager(manager);
+	public void createProcesses(String fileName, Consumer<TemplateProcess> process) {
-		}
+		List<ModulePackage> packages = getPackagesByRequirement(requirements.get(fileName));
-		for(int i = 0,m=modules.size();i<m;i++) {
+		for(int i = 0,m=packages.size();i<m;i++) {
-			biPackages.forEach(modules.get(i)::init);
+			packages.get(i).process(fileName, process);
-		}
+		}
-		for(int i = 0,m=modules.size();i<m;i++) {
+	}
-			modules.get(i).cleanup();
+	
-		}
+	protected List<ModulePackage> getPackagesByRequirement(RequiredType type) {
-	}
+		if(type == null) return simplePackages;
-	
+		if(type == RequiredType.BI_CLASS) return biPackages;
-	private void finishPackages() 
+		if(type == RequiredType.ENUM) return enumPackages;
-	{
+		return Collections.emptyList();
-		biPackages.forEach(ModulePackage::finish);
+	}
-		if((flags & SAVE) != 0) manager.save();
+	
-	}
+	private String getModuleInfo(Path basePath) {
-	
+		StringJoiner joiner = new StringJoiner("\n", "", "\n");
-	private void prepPackages()
+		try(Stream<Path> stream = Files.walk(getOutputFolder())) {
-	{
+			stream.filter(Files::isDirectory)
-		if((flags & LOAD) != 0) manager.load();
+					.filter(this::containsFiles)
-		for(ModulePackage entry : ModulePackage.createPackages(globalFlags))
+					.map(basePath::relativize)
-		{
+					.map(Path::toString)
-			entry.setRequirements(requirements::put);
+					.map(this::sanitize)
-			biPackages.add(entry);
+					.forEach(T -> joiner.add("\texports "+T+";"));
-			if(entry.isSame()) simplePackages.add(entry);
+		}
-			if(entry.isEnumValid()) enumPackages.add(entry);
+		catch(Exception e) {
-		}		
+			e.printStackTrace();
-	}
+			throw new RuntimeException(e);
-	
+		}
-	@Override
+		StringBuilder builder = new StringBuilder();
-	public void createProcesses(String fileName, Consumer<TemplateProcess> process)
+		builder.append("/** @author Speiger */\n");
-	{
+		builder.append("module ").append(sanitize(basePath.relativize(getOutputFolder()).toString())).append(" {\n");
-		List<ModulePackage> packages = getPackagesByRequirement(requirements.get(fileName));
+		builder.append(joiner.toString()).append("}");	
-		for(int i = 0,m=packages.size();i<m;i++)
+		return builder.toString();
-		{
+	}
-			packages.get(i).process(fileName, process);
+	
-		}
+	private String sanitize(String input) {
-	}
+		return input.replace("\\", ".").replace("/", ".");
-	
+	}
-	protected List<ModulePackage> getPackagesByRequirement(RequiredType type) {
+	
-		if(type == null) return simplePackages;
+	private boolean containsFiles(Path path)  {
-		if(type == RequiredType.BI_CLASS) return biPackages;
+		try(Stream<Path> stream = Files.walk(path, 1)) {
-		if(type == RequiredType.ENUM) return enumPackages;
+			return stream.filter(Files::isRegularFile).findFirst().isPresent();
-		return Collections.emptyList();
+		}
-	}
+		catch(Exception e) { e.printStackTrace(); }
-	
+		return false;
-	private String getModuleInfo(Path basePath) {
+	}
-		StringJoiner joiner = new StringJoiner("\n", "", "\n");
+	
-		try(Stream<Path> stream = Files.walk(getOutputFolder()))
+	private int getVersion() {
-		{
+		String version = System.getProperty("java.version");
-			stream.filter(Files::isDirectory)
+		if(version.startsWith("1.")) return Integer.parseInt(version.substring(2, 3));
-					.filter(this::containsFiles)
+		int dot = version.indexOf(".");
-					.map(basePath::relativize)
+		return Integer.parseInt(dot != -1 ? version.substring(0, dot) : version);
-					.map(Path::toString)
+	}
-					.map(this::sanitize)
+	
-					.forEach(T -> joiner.add("\texports "+T+";"));
+	public static void main(String...args) {
-		}
+		try
-		catch(Exception e)
+		{
-		{
+			Set<String> flags = new HashSet<>(Arrays.asList(args));
-			e.printStackTrace();
+			boolean silent = flags.contains("silent");
-			throw new RuntimeException(e);
+			boolean force = flags.contains("force");
-		}
+			boolean tests = flags.contains("tests");
-		StringBuilder builder = new StringBuilder();
+			boolean forceTests =  flags.contains("force-tests");
-		builder.append("/** @author Speiger */\n");
+			boolean load = flags.contains("load");
-		builder.append("module ").append(sanitize(basePath.relativize(getOutputFolder()).toString())).append(" {\n");
+			boolean save = flags.contains("save");
-		builder.append(joiner.toString()).append("}");	
+			int flag = (load ? LOAD : 0) | (save ? SAVE : 0);
-		return builder.toString();
+            new PrimitiveCollectionsBuilder(silent).setFlags(flag).process(force);
-	}
+            if(tests) {
-	
+    			createTests(silent, flag).process(force || forceTests);
-	private String sanitize(String input)
+    			createTesters(silent, flag).process(force || forceTests);
-	{
+            }
-		return input.replace("\\", ".").replace("/", ".");
+        }
-	}
+		catch(InterruptedException | IOException e)
-	
+		{
-	private boolean containsFiles(Path path) 
+			e.printStackTrace();
-	{
+		}
-		try(Stream<Path> stream = Files.walk(path, 1))
+	}
-		{
+}
-			return stream.filter(Files::isRegularFile).findFirst().isPresent();
-		}
-		catch(Exception e)
-		{
-			e.printStackTrace();
-		}
-		return false;
-	}
-	
-	private int getVersion() 
-	{
-		String version = System.getProperty("java.version");
-		if(version.startsWith("1.")) return Integer.parseInt(version.substring(2, 3));
-		int dot = version.indexOf(".");
-		return Integer.parseInt(dot != -1 ? version.substring(0, dot) : version);
-	}
-	
-	public static void main(String...args)
-	{
-		try
-		{
-			Set<String> flags = new HashSet<>(Arrays.asList(args));
-			boolean silent = flags.contains("silent");
-			boolean force = flags.contains("force");
-			boolean tests = flags.contains("tests");
-			boolean forceTests =  flags.contains("force-tests");
-			boolean load = flags.contains("load");
-			boolean save = flags.contains("save");
-			int flag = (load ? LOAD : 0) | (save ? SAVE : 0);
-            new PrimitiveCollectionsBuilder(silent).setFlags(flag).process(force);
-            if(tests) {
-    			createTests(silent, flag).process(force || forceTests);
-    			createTesters(silent, flag).process(force || forceTests);
-            }
-        }
-		catch(InterruptedException | IOException e)
-		{
-			e.printStackTrace();
-		}
-	}
-}

src/builder/java/speiger/src/builder/modules/BaseModule.java

@@ -59,6 +59,9 @@ public abstract class BaseModule
 	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) { return Collections.emptySet(); }
 	public boolean isModuleValid(ClassType keyType, ClassType valueType) { return true; }
 	
+	public ClassType keyType() { return keyType; }
+	public ClassType valueType() { return valueType; }
+	
 	protected boolean isModuleEnabled() {
 		return manager == null || manager.isModuleEnabled(this, keyType, valueType);
 	}
@@ -83,6 +86,10 @@ public abstract class BaseModule
 		entry.addFlag(name);
 	}
 	
+	protected void addValue(String name, int value) {
+		entry.addValue(name, value);
+	}
+	
 	protected void addKeyFlag(String name) {
 		entry.addFlag(name);
 		entry.addGlobalFlag(keyType.getCapType()+"_"+name);

src/builder/java/speiger/src/builder/modules/FunctionModule.java

@@ -1,5 +1,8 @@
 package speiger.src.builder.modules;
 
+import speiger.src.builder.ClassType;
+import speiger.src.builder.RequiredType;
+
 @SuppressWarnings("javadoc")
 public class FunctionModule extends BaseModule
 {
@@ -27,7 +30,23 @@ public class FunctionModule extends BaseModule
 	{
 		addBiRequirement("BiConsumer", "");
 		addBiRequirement("UnaryOperator", "");
-		addBiRequirement("Function");
+		if(valueType == ClassType.BOOLEAN) {
+			addRequirement("Function", "%1$s", RequiredType.BI_CLASS);
+			addRemapper("Function", (keyType.isObject() ? "" : "%s")+"Predicate");
+		}
+		else if(keyType.isObject() && !valueType.isObject()) {
+			addRequirement("Function", "%2$s", RequiredType.BI_CLASS);
+			addRemapper("Function", "To%sFunction");			
+		}
+		else if(keyType == valueType) {
+			addRequirement("Function", "%1$s", RequiredType.BI_CLASS);
+			addRemapper("Function", (keyType.isObject() ? "" : "%s")+"UnaryOperator");
+		}
+		else if(valueType.isObject()) {
+			addRequirement("Function", "%1$s", RequiredType.BI_CLASS);
+			addRemapper("Function", "%sFunction");
+		}
+		else addBiRequirement("Function");
 		addRemapper("BiConsumer", "%sConsumer");
 	}
 	
@@ -35,6 +54,8 @@ public class FunctionModule extends BaseModule
 	protected void loadFunctions()
 	{
 		addSimpleMapper("APPLY", keyType.getApply(valueType));
+		addSimpleMapper("SUPPLY_GET", keyType.isObject() ? "get" : "getAs"+keyType.getNonFileType());
+		addSimpleMapper("VALUE_SUPPLY_GET", valueType.isObject() ? "get" : "getAs"+valueType.getNonFileType());
 	}
 	
 	@Override
@@ -44,9 +65,22 @@ public class FunctionModule extends BaseModule
 		addBiClassMapper("BI_CONSUMER", "Consumer", "");
 		addClassMapper("BI_TO_OBJECT_CONSUMER", "ObjectConsumer");
 		addAbstractMapper("BI_FROM_OBJECT_CONSUMER", "Object%sConsumer");
-		addClassMapper("TO_OBJECT_FUNCTION", "2ObjectFunction");
+		addAbstractMapper("BI_FROM_INT_CONSUMER", "Int%sConsumer");
-		addBiClassMapper("FUNCTION", "Function", "2");
+		if(keyType.isObject()) {
-		addClassMapper("PREDICATE", "2BooleanFunction");
+			addSimpleMapper("TO_OBJECT_FUNCTION", keyType.getNonFileType()+"UnaryOperator");
+			addSimpleMapper("VALUE_TO_OBJECT_FUNCTION", valueType.isObject() ? "UnaryOperator" : valueType.getFileType()+"Function");
+		}
+		else {
+			addSimpleMapper("TO_OBJECT_FUNCTION", keyType.getNonFileType()+"Function");
+			addSimpleMapper("VALUE_TO_OBJECT_FUNCTION", valueType.isObject() ? "UnaryOperator" : valueType.getFileType()+"Function");
+		}
+		if(valueType == ClassType.BOOLEAN) addFunctionMappers("FUNCTION", "%sPredicate");
+		else if(keyType.isObject() && !valueType.isObject()) addFunctionValueMappers("FUNCTION", "To%sFunction");
+		else if(keyType == valueType) addFunctionMappers("FUNCTION", "%sUnaryOperator");
+		else if(valueType.isObject()) addFunctionMappers("FUNCTION", "%sFunction");
+		else addBiClassMapper("FUNCTION", "Function", "2");
+		
+		addFunctionMappers("PREDICATE", "%sPredicate");
 		addClassMapper("SUPPLIER", "Supplier");
 		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
 		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");

src/builder/java/speiger/src/builder/modules/JavaModule.java

@@ -1,204 +1,221 @@
-package speiger.src.builder.modules;
+package speiger.src.builder.modules;
-
+
-import speiger.src.builder.ClassType;
+import speiger.src.builder.ClassType;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class JavaModule extends BaseModule
+public class JavaModule extends BaseModule
-{
+{
-	public static final BaseModule INSTANCE = new JavaModule();
+	public static final BaseModule INSTANCE = new JavaModule();
-	
+	
-	@Override
+	@Override
-	public String getModuleName() { return "Base"; }
+	public String getModuleName() { return "Base"; }
-	@Override
+	@Override
-	protected void loadVariables()
+	protected void loadVariables()
-	{
+	{
-		createHelperVars(keyType, false, "KEY");
+		createHelperVars(keyType, false, "KEY");
-		createHelperVars(valueType, true, "VALUE");
+		createHelperVars(valueType, true, "VALUE");
-		loadBaseVariables();
+		loadBaseVariables();
-	}
+	}
-	
+	
-	@Override
+	@Override
-	protected void loadFlags()
+	protected void loadFlags()
-	{
+	{
-		addFlag("TYPE_"+keyType.getCapType());
+		addFlag("TYPE_"+keyType.getCapType());
-		addFlag("VALUE_"+valueType.getCapType());
+		addFlag("VALUE_"+valueType.getCapType());
-		if(keyType == valueType) addFlag("SAME_TYPE");
+		addValue("JAVA_VERSION", getVersion());
-		if(keyType.hasFunction(valueType)) addFlag("JDK_FUNCTION");
+		if(keyType == valueType) addFlag("SAME_TYPE");
-		if(!keyType.needsCustomJDKType()) addFlag("JDK_TYPE");
+		if(keyType.hasFunction(valueType)) addFlag("JDK_FUNCTION");
-		if(!keyType.isPrimitiveBlocking()) addFlag("PRIMITIVES");
+		if(!keyType.needsCustomJDKType()) addFlag("JDK_TYPE");
-		if(!valueType.isPrimitiveBlocking()) addFlag("VALUE_PRIMITIVES");
+		if(!keyType.isPrimitiveBlocking()) addFlag("PRIMITIVES");
-		if(valueType.needsCustomJDKType()) addFlag("JDK_VALUE");
+		if(!valueType.isPrimitiveBlocking()) addFlag("VALUE_PRIMITIVES");
-	}
+		if(!valueType.needsCustomJDKType()) addFlag("JDK_VALUE");
-	
+	}
-	@Override
+	
-	protected void loadRemappers() {}
+	private int getVersion()  {
-	@Override
+		String version = System.getProperty("java.version");
-	protected void loadBlockades() {}
+		if(version.startsWith("1.")) return Integer.parseInt(version.substring(2, 3));
-	
+		int dot = version.indexOf(".");
-	@Override
+		return Integer.parseInt(dot != -1 ? version.substring(0, dot) : version);
-	protected void loadFunctions()
+	}
-	{
+	
-		addSimpleMapper("APPLY_KEY_VALUE", keyType.isObject() ? "apply" : "applyAs"+keyType.getNonFileType());
+	@Override
-		addSimpleMapper("APPLY_VALUE", valueType.isObject() ? "apply" : "applyAs"+valueType.getNonFileType());
+	protected void loadRemappers() {}
-		addSimpleMapper("APPLY_CAST", "applyAs"+keyType.getCustomJDKType().getNonFileType());
+	@Override
-		
+	protected void loadBlockades() {}
-		//Shared by Maps and Pairs so moved to java.
+	
-		addFunctionMappers("ENTRY_KEY", "get%sKey");
+	@Override
-		addFunctionValueMappers("ENTRY_VALUE", "get%sValue");
+	protected void loadFunctions()
-		addFunctionMappers("KEY_ENTRY", "set%sKey");
+	{
-		addFunctionValueMappers("VALUE_ENTRY", "set%sValue");
+		addSimpleMapper("APPLY_KEY_VALUE", keyType.isObject() ? "apply" : "applyAs"+keyType.getNonFileType());
-	}
+		addSimpleMapper("APPLY_VALUE", valueType.isObject() ? "apply" : "applyAs"+valueType.getNonFileType());
-	
+		addSimpleMapper("APPLY_CAST", "applyAs"+keyType.getCustomJDKType().getNonFileType());
-	@Override
+		
-	protected void loadClasses()
+		//Shared by Maps and Pairs so moved to java.
-	{
+		addFunctionMappers("ENTRY_KEY", "get%sKey");
-		addSimpleMapper("JAVA_PREDICATE", keyType.isPrimitiveBlocking() ? "" : keyType.getCustomJDKType().getFileType()+"Predicate");
+		addFunctionValueMappers("ENTRY_VALUE", "get%sValue");
-		addSimpleMapper("JAVA_CONSUMER", keyType.isPrimitiveBlocking() ? "" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"Consumer");
+		addFunctionMappers("KEY_ENTRY", "set%sKey");
-		addSimpleMapper("JAVA_SUPPLIER", keyType.isPrimitiveBlocking() ? "" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"Supplier");
+		addFunctionValueMappers("VALUE_ENTRY", "set%sValue");
-		addSimpleMapper("JAVA_FUNCTION", keyType.getFunctionClass(valueType));
+	}
-		addSimpleMapper("JAVA_BINARY_OPERATOR", keyType == ClassType.BOOLEAN ? "" : (keyType.isObject() ? "java.util.function.BinaryOperator" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"BinaryOperator"));
+	
-		addSimpleMapper("JAVA_UNARY_OPERATOR", keyType.isObject() ? "BinaryOperator" : keyType == ClassType.BOOLEAN ? "" : keyType.getCustomJDKType().getFileType()+"UnaryOperator");
+	@Override
-		addSimpleMapper("JAVA_SPLIT_ITERATOR", keyType.isPrimitiveBlocking() ? "Spliterator" : "Of"+keyType.getCustomJDKType().getFileType());
+	protected void loadClasses()
-		addSimpleMapper("JAVA_STREAM", keyType.isPrimitiveBlocking() ? "" : keyType.getCustomJDKType().getFileType()+"Stream");
+	{
-		addSimpleMapper("JAVA_BUFFER", keyType.getFileType()+"Buffer");
+		if(getVersion() >= 17) addSimpleMapper("RANDOM", "RandomGenerator");
-	}
+		else addSimpleMapper("RANDOM", "Random");
-	
+		addSimpleMapper("JAVA_PREDICATE", keyType.isPrimitiveBlocking() ? "" : keyType.getCustomJDKType().getFileType()+"Predicate");
-	@Override
+		addSimpleMapper("JAVA_CONSUMER", keyType.isPrimitiveBlocking() ? "" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"Consumer");
-	protected void loadTestClasses()
+		addSimpleMapper("JAVA_SUPPLIER", keyType.isPrimitiveBlocking() ? "" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"Supplier");
-	{
+		addSimpleMapper("JAVA_FUNCTION", keyType.getFunctionClass(valueType));
-		addClassMapper("HELPERS", "Helpers");
+		addSimpleMapper("JAVA_BINARY_OPERATOR", keyType == ClassType.BOOLEAN ? "" : (keyType.isObject() ? "java.util.function.BinaryOperator" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"BinaryOperator"));
-		addClassMapper("SAMPLE_ELEMENTS", "Samples");
+		addSimpleMapper("JAVA_UNARY_OPERATOR", keyType.isObject() ? "BinaryOperator" : keyType == ClassType.BOOLEAN ? "" : keyType.getCustomJDKType().getFileType()+"UnaryOperator");
-	}
+		addSimpleMapper("JAVA_SPLIT_ITERATOR", keyType.isPrimitiveBlocking() ? "Spliterator" : "Of"+keyType.getCustomJDKType().getFileType());
-	
+		addSimpleMapper("JAVA_STREAM", keyType.isPrimitiveBlocking() ? "" : keyType.getCustomJDKType().getFileType()+"Stream");
-	private void loadBaseVariables()
+		addSimpleMapper("JAVA_BUFFER", keyType.getFileType()+"Buffer");
-	{
+	}
-		addSimpleMapper("VALUE_PACKAGE", valueType.getPathType());
+	
-		addSimpleMapper("PACKAGE", keyType.getPathType());
+	@Override
-		addSimpleMapper("CLASS_TYPE", keyType.getClassType());
+	protected void loadTestClasses()
-		addSimpleMapper("CLASS_VALUE_TYPE", valueType.getClassValueType());
+	{
-		addSimpleMapper("KEY_TYPE", keyType.getKeyType());
+		addClassMapper("HELPERS", "Helpers");
-		addSimpleMapper("KEY_OBJECT_TYPE", keyType.isObject() ? "Object" : keyType.getKeyType());
+		addClassMapper("SAMPLE_ELEMENTS", "Samples");
-		addSimpleMapper("KEY_STRING_TYPE", keyType.isObject() ? "String" : keyType.getKeyType());
+	}
-		addSimpleMapper("KEY_SPECIAL_TYPE", keyType.isObject() ? "E" : keyType.getKeyType());
+	
-		addSimpleMapper("CLASS_OBJECT_TYPE", keyType.getClassType());
+	private void loadBaseVariables()
-		addSimpleMapper("CLASS_OBJECT_VALUE_TYPE", valueType.getClassValueType());
+	{
-		addSimpleMapper("CLASS_STRING_TYPE", keyType.isObject() ? "String" : keyType.getClassType());
+		addSimpleMapper("VALUE_PACKAGE", valueType.getPathType());
-		addSimpleMapper("CLASS_STRING_VALUE_TYPE", valueType.isObject() ? "String" : valueType.getClassValueType());
+		addSimpleMapper("PACKAGE", keyType.getPathType());
-		addSimpleMapper("VALUE_TYPE", valueType.getValueType());
+		addSimpleMapper("CLASS_TYPE", keyType.getClassType());
-		addSimpleMapper("VALUE_OBJECT_TYPE", valueType.isObject() ? "Object" : valueType.getValueType());
+		addSimpleMapper("CLASS_VALUE_TYPE", valueType.getClassValueType());
-		addSimpleMapper("VALUE_STRING_TYPE", valueType.isObject() ? "String" : valueType.getValueType());
+		addSimpleMapper("KEY_TYPE", keyType.getKeyType());
-		addSimpleMapper("VALUE_SPECIAL_TYPE", valueType.isObject() ? "E" : valueType.getKeyType());
+		addSimpleMapper("KEY_OBJECT_TYPE", keyType.isObject() ? "Object" : keyType.getKeyType());
-		addSimpleMapper("KEY_JAVA_TYPE", keyType.getCustomJDKType().getKeyType());
+		addSimpleMapper("KEY_STRING_TYPE", keyType.isObject() ? "String" : keyType.getKeyType());
-		addSimpleMapper("VALUE_JAVA_TYPE", keyType.getCustomJDKType().getKeyType());
+		addSimpleMapper("KEY_SPECIAL_TYPE", keyType.isObject() ? "E" : keyType.getKeyType());
-		
+		addSimpleMapper("CLASS_OBJECT_TYPE", keyType.getClassType());
-		addSimpleMapper("EMPTY_KEY_VALUE", keyType.getEmptyValue());
+		addSimpleMapper("CLASS_OBJECT_VALUE_TYPE", valueType.getClassValueType());
-		addSimpleMapper("EMPTY_VALUE", valueType.getEmptyValue());
+		addSimpleMapper("CLASS_STRING_TYPE", keyType.isObject() ? "String" : keyType.getClassType());
-		
+		addSimpleMapper("CLASS_STRING_VALUE_TYPE", valueType.isObject() ? "String" : valueType.getClassValueType());
-		addSimpleMapper("INVALID_KEY_VALUE", keyType.getInvalidValue());
+		addSimpleMapper("VALUE_TYPE", valueType.getValueType());
-		addSimpleMapper("INVALID_VALUE", valueType.getInvalidValue());
+		addSimpleMapper("VALUE_OBJECT_TYPE", valueType.isObject() ? "Object" : valueType.getValueType());
-		
+		addSimpleMapper("VALUE_STRING_TYPE", valueType.isObject() ? "String" : valueType.getValueType());
-		addSimpleMapper(" KEY_STRING_GENERIC_TYPE", keyType.isObject() ? "<String>" : "");
+		addSimpleMapper("VALUE_SPECIAL_TYPE", valueType.isObject() ? "E" : valueType.getKeyType());
-		addSimpleMapper(" VALUE_STRING_GENERIC_TYPE", valueType.isObject() ? "<String>" : "");
+		addSimpleMapper("KEY_JAVA_TYPE", keyType.getCustomJDKType().getKeyType());
-		addSimpleMapper(" KEY_VALUE_STRING_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<String, String>" : "<String>") : (valueType.isObject() ? "<String>" : ""));
+		addSimpleMapper("VALUE_JAVA_TYPE", keyType.getCustomJDKType().getKeyType());
-
+		
-		
+		addSimpleMapper("EMPTY_KEY_VALUE", keyType.getEmptyValue());
-		addSimpleMapper(" KEY_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+">" : "");
+		addSimpleMapper("EMPTY_VALUE", valueType.getEmptyValue());
-		addSimpleMapper(" KEY_KEY_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+", "+keyType.getKeyType()+">" : "");
+		
-		addSimpleMapper(" KEY_CLASS_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getClassType()+">" : "");
+		addSimpleMapper("INVALID_KEY_VALUE", keyType.getInvalidValue());
-
+		addSimpleMapper("INVALID_VALUE", valueType.getInvalidValue());
-		
+		
-		addSimpleMapper(" VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+">" : "");
+		addSimpleMapper(" KEY_STRING_GENERIC_TYPE", keyType.isObject() ? "<String>" : "");
-		addSimpleMapper(" VALUE_VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : "");
+		addSimpleMapper(" VALUE_STRING_GENERIC_TYPE", valueType.isObject() ? "<String>" : "");
-		addSimpleMapper(" VALUE_CLASS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getClassValueType()+">" : "");
+		addSimpleMapper(" KEY_VALUE_STRING_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<String, String>" : "<String>") : (valueType.isObject() ? "<String>" : ""));
-		
+		
-		addSimpleMapper(" KEY_VALUE_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
+		addSimpleMapper(" KEY_SAME_GENERIC_TYPE", keyType.isObject() ? "<T, T>" : "");
-		addSimpleMapper(" KEY_VALUE_VALUE_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+", "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : ""));
+		addSimpleMapper(" VALUE_SAME_GENERIC_TYPE", keyType.isObject() ? "<V, V>" : "");
-		addInjectMapper(" KEY_VALUE_SPECIAL_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+", %s>" : "<"+keyType.getKeyType()+", %s>") : (valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>")).setBraceType("<>").removeBraces();
+		
-		
+		addSimpleMapper(" KEY_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+">" : "");
-		addSimpleMapper(" NO_GENERIC_TYPE", keyType.isObject() ? "<?>" : "");
+		addSimpleMapper(" KEY_KEY_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+", "+keyType.getKeyType()+">" : "");
-		addSimpleMapper(" NO_KV_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<?, ?>" : "<?>") : valueType.isObject() ? "<?>" : "");
+		addSimpleMapper(" KEY_CLASS_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getClassType()+">" : "");
-		addSimpleMapper(" KEY_COMPAREABLE_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+" extends Comparable<T>>" : "");
+
-		
+		
-		addSimpleMapper(" KEY_SUPER_GENERIC_TYPE", keyType.isObject() ? "<? super "+keyType.getKeyType()+">" : "");
+		addSimpleMapper(" VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+">" : "");
-		addSimpleMapper(" VALUE_SUPER_GENERIC_TYPE", valueType.isObject() ? "<? super "+valueType.getValueType()+">" : "");
+		addSimpleMapper(" VALUE_VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : "");
-		addSimpleMapper(" KEY_VALUE_SUPER_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<? super "+keyType.getKeyType()+", ? super "+valueType.getValueType()+">" : "<? super "+keyType.getKeyType()+">") : (valueType.isObject() ? "<? super "+valueType.getValueType()+">" : ""));
+		addSimpleMapper(" VALUE_CLASS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getClassValueType()+">" : "");
-		
+		
-		addSimpleMapper(" KEY_UNKNOWN_GENERIC_TYPE", keyType.isObject() ? "<? extends "+keyType.getKeyType()+">" : "");
+		addSimpleMapper(" KEY_VALUE_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
-		addSimpleMapper(" VALUE_UNKNOWN_GENERIC_TYPE", valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : "");
+		addSimpleMapper(" KEY_VALUE_VALUE_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+", "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : ""));
-		addSimpleMapper(" KEY_VALUE_UNKNOWN_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<? extends "+keyType.getKeyType()+", ? extends "+valueType.getValueType()+">" : "<? extends "+keyType.getKeyType()+">") : (valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : ""));
+		addInjectMapper(" KEY_VALUE_SPECIAL_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+", %s>" : "<"+keyType.getKeyType()+", %s>") : (valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>")).setBraceType("<>").removeBraces();
-
+		
-		addSimpleMapper(" KEY_ENUM_VALUE_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">, "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">>") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
+		addSimpleMapper(" NO_GENERIC_TYPE", keyType.isObject() ? "<?>" : "");
-		addSimpleMapper(" KEY_VALUE_ENUM_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : ""));
+		addSimpleMapper(" NO_KV_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<?, ?>" : "<?>") : valueType.isObject() ? "<?>" : "");
-		
+		addSimpleMapper(" KEY_COMPAREABLE_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+" extends Comparable<T>>" : "");
-		addInjectMapper(" KEY_SPECIAL_GENERIC_TYPE", keyType.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
+		
-		addInjectMapper(" VALUE_SPECIAL_GENERIC_TYPE", valueType.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
+		addSimpleMapper(" KEY_SUPER_GENERIC_TYPE", keyType.isObject() ? "<? super "+keyType.getKeyType()+">" : "");
-		addInjectMapper(" KSK_GENERIC_TYPE", keyType.isObject() ? "<%s, "+keyType.getKeyType()+">" : "<%s>").removeBraces().setBraceType("<>");
+		addSimpleMapper(" VALUE_SUPER_GENERIC_TYPE", valueType.isObject() ? "<? super "+valueType.getValueType()+">" : "");
-		addInjectMapper(" KKS_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
+		addSimpleMapper(" KEY_VALUE_SUPER_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<? super "+keyType.getKeyType()+", ? super "+valueType.getValueType()+">" : "<? super "+keyType.getKeyType()+">") : (valueType.isObject() ? "<? super "+valueType.getValueType()+">" : ""));
-		addArgumentMapper(" KSS_GENERIC_TYPE", keyType.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
+		
-		addInjectMapper(" VSV_GENERIC_TYPE", valueType.isObject() ? "<%s, "+valueType.getValueType()+">" : "<%s>").removeBraces().setBraceType("<>");
+		addSimpleMapper(" KEY_UNKNOWN_GENERIC_TYPE", keyType.isObject() ? "<? extends "+keyType.getKeyType()+">" : "");
-		addInjectMapper(" VVS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
+		addSimpleMapper(" VALUE_UNKNOWN_GENERIC_TYPE", valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : "");
-		addArgumentMapper(" VSS_GENERIC_TYPE", valueType.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
+		addSimpleMapper(" KEY_VALUE_UNKNOWN_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<? extends "+keyType.getKeyType()+", ? extends "+valueType.getValueType()+">" : "<? extends "+keyType.getKeyType()+">") : (valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : ""));
-
+
-		addSimpleMapper(" GENERIC_KEY_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+">" : "");
+		addSimpleMapper(" KEY_ENUM_VALUE_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">, "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">>") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
-		addSimpleMapper(" GENERIC_VALUE_BRACES", valueType.isObject() ? " <"+valueType.getValueType()+">" : "");
+		addSimpleMapper(" KEY_VALUE_ENUM_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : ""));
-		addInjectMapper(" GENERIC_SPECIAL_KEY_BRACES", keyType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
+		
-		addInjectMapper(" GENERIC_SPECIAL_VALUE_BRACES", valueType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
+		addInjectMapper(" KEY_SPECIAL_GENERIC_TYPE", keyType.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
-		addSimpleMapper(" GENERIC_KEY_ENUM_VALUE_BRACES", keyType.isObject() ? (valueType.isObject() ? " <"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">, "+valueType.getValueType()+">" : " <"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">>") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
+		addInjectMapper(" VALUE_SPECIAL_GENERIC_TYPE", valueType.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
-		
+		addInjectMapper(" KSK_GENERIC_TYPE", keyType.isObject() ? "<%s, "+keyType.getKeyType()+">" : "<%s>").removeBraces().setBraceType("<>");
-		addInjectMapper(" GENERIC_KEY_SPECIAL_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
+		addInjectMapper(" KKS_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
-		addInjectMapper(" GENERIC_VALUE_SPECIAL_BRACES", valueType.isObject() ? " <"+valueType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
+		addArgumentMapper(" KSS_GENERIC_TYPE", keyType.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
-		
+		addInjectMapper(" SK_GENERIC_TYPE", keyType.isObject() ? "<%s, "+keyType.getKeyType()+">" : "").removeBraces().setBraceType("<>");
-		addSimpleMapper(" GENERIC_KEY_VALUE_BRACES", keyType.isObject() ? (valueType.isObject() ? " <"+keyType.getKeyType()+", "+valueType.getValueType()+">" : " <"+keyType.getKeyType()+">") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
+		addInjectMapper(" KS_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+", %s>" : "").removeBraces().setBraceType("<>");
-		addSimpleMapper(" COMPAREABLE_KEY_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+" extends Comparable<T>>" : "");
+		addInjectMapper(" VSV_GENERIC_TYPE", valueType.isObject() ? "<%s, "+valueType.getValueType()+">" : "<%s>").removeBraces().setBraceType("<>");
-		addSimpleMapper("KV_BRACES", keyType.isObject() || valueType.isObject() ? "<>" : "");
+		addInjectMapper(" VVS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
-		addSimpleMapper("VALUE_BRACES", valueType.isObject() ? "<>" : "");
+		addArgumentMapper(" VSS_GENERIC_TYPE", valueType.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");	
-		addSimpleMapper("BRACES", keyType.isObject() ? "<>" : "");
+		addInjectMapper(" SV_GENERIC_TYPE", valueType.isObject() ? "<%s, "+valueType.getValueType()+">" : "").removeBraces().setBraceType("<>");
-		if(keyType.needsCustomJDKType())
+		addInjectMapper(" VS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "").removeBraces().setBraceType("<>");
-		{
+
-			addSimpleMapper("JAVA_TYPE", keyType.getCustomJDKType().getKeyType());
+
-			addSimpleMapper("SANITY_CAST", "castTo"+keyType.getFileType());
+		addSimpleMapper(" GENERIC_KEY_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+">" : "");
-		}
+		addSimpleMapper(" GENERIC_VALUE_BRACES", valueType.isObject() ? " <"+valueType.getValueType()+">" : "");
-		addSimpleMapper("JAVA_CLASS", keyType.getCustomJDKType().getClassType());
+		addInjectMapper(" GENERIC_SPECIAL_KEY_BRACES", keyType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
-		if(valueType.needsCustomJDKType())
+		addInjectMapper(" GENERIC_SPECIAL_VALUE_BRACES", valueType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
-		{
+		addSimpleMapper(" GENERIC_KEY_ENUM_VALUE_BRACES", keyType.isObject() ? (valueType.isObject() ? " <"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">, "+valueType.getValueType()+">" : " <"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">>") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
-			addSimpleMapper("SANITY_CAST_VALUE", "castTo"+valueType.getFileType());
+		
-		}
+		addInjectMapper(" GENERIC_KEY_SPECIAL_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
-		addSimpleMapper("[SPACE]", " ");
+		addInjectMapper(" GENERIC_VALUE_SPECIAL_BRACES", valueType.isObject() ? " <"+valueType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
-		addComment("@ArrayType", "@param <%s> the keyType of array that the operation should be applied");
+		
-		addComment("@Type", "@param <%s> the keyType of elements maintained by this Collection");
+		addSimpleMapper(" GENERIC_KEY_VALUE_BRACES", keyType.isObject() ? (valueType.isObject() ? " <"+keyType.getKeyType()+", "+valueType.getValueType()+">" : " <"+keyType.getKeyType()+">") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
-		addValueComment("@ValueArrayType", "@param <%s> the keyType of array that the operation should be applied");
+		addSimpleMapper(" COMPAREABLE_KEY_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+" extends Comparable<T>>" : "");
-		addValueComment("@ValueType", "@param <%s> the keyType of elements maintained by this Collection");
+		addSimpleMapper("KV_BRACES", keyType.isObject() || valueType.isObject() ? "<>" : "");
-		addAnnontion("@PrimitiveOverride", "@Override");
+		addSimpleMapper("VALUE_BRACES", valueType.isObject() ? "<>" : "");
-		addSimpleMapper("@PrimitiveDoc", "");
+		addSimpleMapper("BRACES", keyType.isObject() ? "<>" : "");
-		addAnnontion("@Primitive", "@Deprecated");
+		if(keyType.needsCustomJDKType())
-		addValueAnnontion("@ValuePrimitiveOverride", "@Override");
+		{
-		addValueAnnontion("@ValuePrimitive", "@Deprecated");
+			addSimpleMapper("JAVA_TYPE", keyType.getCustomJDKType().getKeyType());
-	}
+			addSimpleMapper("SANITY_CAST", "castTo"+keyType.getFileType());
-	
+		}
-	private void createHelperVars(ClassType type, boolean value, String fix)
+		addSimpleMapper("JAVA_CLASS", keyType.getCustomJDKType().getClassType());
-	{
+		if(valueType.needsCustomJDKType())
-		addArgumentMapper("EQUALS_"+fix+"_TYPE", "Objects.equals(%2$s, "+(type.isObject() ? "%1$s" : fix+"_TO_OBJ(%1$s)")+")").removeBraces();
+		{
-		addInjectMapper(fix+"_EQUALS_NOT_NULL", type.getComparableValue()+" != "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
+			addSimpleMapper("SANITY_CAST_VALUE", "castTo"+valueType.getFileType());
-		addInjectMapper(fix+"_EQUALS_NULL", type.getComparableValue()+" == "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
+		}
-		addArgumentMapper(fix+"_EQUALS_NOT", type.getEquals(true)).removeBraces();
+		addSimpleMapper("[SPACE]", " ");
-		addArgumentMapper(fix+"_EQUALS", type.getEquals(false)).removeBraces();
+		addComment("@ArrayType", "@param <%s> the keyType of array that the operation should be applied");
-		addSimpleMapper("FILE_"+fix+"_TYPE", type.getFileType());
+		addComment("@Type", "@param <%s> the keyType of elements maintained by this Collection");
-		
+		addValueComment("@ValueArrayType", "@param <%s> the keyType of array that the operation should be applied");
-		addArgumentMapper("COMPAREABLE_TO_"+fix, type.isObject() ? "((Comparable<"+type.getKeyType(value)+">)%1$s).compareTo(("+type.getKeyType(value)+")%2$s)" : type.getClassType(value)+".compare(%1$s, %2$s)").removeBraces();
+		addValueComment("@ValueType", "@param <%s> the keyType of elements maintained by this Collection");
-		addArgumentMapper("COMPARE_TO_"+fix, type.isObject() ? "%1$s.compareTo(%2$s)" : type.getClassType(value)+".compare(%1$s, %2$s)").removeBraces();
+		addAnnontion("@PrimitiveOverride", "@Override");
-		
+		addSimpleMapper("@PrimitiveDoc", "");
-		addInjectMapper(fix+"_TO_OBJ", type.isObject() ? "%s" : type.getClassType(value)+".valueOf(%s)").removeBraces();
+		addAnnontion("@Primitive", "@Deprecated");
-		addInjectMapper("OBJ_TO_"+fix, type.isObject() ? "%s" : "%s."+type.getKeyType(value)+"Value()").removeBraces();
+		addValueAnnontion("@ValuePrimitiveOverride", "@Override");
-		addInjectMapper("CLASS_TO_"+fix, type.isObject() ? "("+type.getKeyType(value)+")%s" : "(("+type.getClassType(value)+")%s)."+type.getKeyType(value)+"Value()").removeBraces();
+		addValueAnnontion("@ValuePrimitive", "@Deprecated");
-		
+	}
-		addInjectMapper(fix+"_TO_HASH", type.isObject() ? "Objects.hashCode(%s)" : type.getClassType(value)+".hashCode(%s)").removeBraces();
+	
-		addInjectMapper(fix+"_TO_STRING", type.isObject() ? "Objects.toString(%s)" : type.getClassType(value)+".toString(%s)").removeBraces();
+	private void createHelperVars(ClassType type, boolean value, String fix)
-		
+	{
-		addSimpleMapper("CAST_"+fix+"_ARRAY ", type.isObject() ? "("+fix+"_TYPE[])" : "");
+		addArgumentMapper("EQUALS_"+fix+"_TYPE", "Objects.equals(%2$s, "+(type.isObject() ? "%1$s" : fix+"_TO_OBJ(%1$s)")+")").removeBraces();
-		addSimpleMapper("EMPTY_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])ARRAYS.EMPTY_ARRAY" : "ARRAYS.EMPTY_ARRAY");
+		addInjectMapper(fix+"_EQUALS_NOT_NULL", type.getComparableValue()+" != "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
-		addInjectMapper("NEW_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])new Object[%s]" : "new "+fix+"_TYPE[%s]").removeBraces();
+		addInjectMapper(fix+"_EQUALS_NULL", type.getComparableValue()+" == "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
-		addInjectMapper("NEW_SPECIAL_"+fix+"_ARRAY", type.isObject() ? "(E[])new Object[%s]" : "new "+fix+"_TYPE[%s]").removeBraces();
+		addArgumentMapper(fix+"_EQUALS_NOT", type.getEquals(true)).removeBraces();
-		if(value) addInjectMapper("NEW_CLASS_VALUE_ARRAY", type.isObject() ? "(CLASS_VALUE_TYPE[])new Object[%s]" : "new CLASS_VALUE_TYPE[%s]").removeBraces();
+		addArgumentMapper(fix+"_EQUALS", type.getEquals(false)).removeBraces();
-		else addInjectMapper("NEW_CLASS_ARRAY", type.isObject() ? "(CLASS_TYPE[])new Object[%s]" : "new CLASS_TYPE[%s]").removeBraces();
+		addSimpleMapper("FILE_"+fix+"_TYPE", type.getFileType());
-	}
+		
-}
+		addArgumentMapper("COMPAREABLE_TO_"+fix, type.isObject() ? "((Comparable<"+type.getKeyType(value)+">)%1$s).compareTo(("+type.getKeyType(value)+")%2$s)" : type.getClassType(value)+".compare(%1$s, %2$s)").removeBraces();
+		addArgumentMapper("COMPARE_TO_"+fix, type.isObject() ? "%1$s.compareTo(%2$s)" : type.getClassType(value)+".compare(%1$s, %2$s)").removeBraces();
+		
+		addInjectMapper(fix+"_TO_OBJ", type.isObject() ? "%s" : type.getClassType(value)+".valueOf(%s)").removeBraces();
+		addInjectMapper("OBJ_TO_"+fix, type.isObject() ? "%s" : "%s."+type.getKeyType(value)+"Value()").removeBraces();
+		addInjectMapper("CLASS_TO_"+fix, type.isObject() ? "("+type.getKeyType(value)+")%s" : "(("+type.getClassType(value)+")%s)."+type.getKeyType(value)+"Value()").removeBraces();
+		
+		addInjectMapper(fix+"_TO_HASH", type.isObject() ? "Objects.hashCode(%s)" : type.getClassType(value)+".hashCode(%s)").removeBraces();
+		addInjectMapper(fix+"_TO_STRING", type.isObject() ? "Objects.toString(%s)" : type.getClassType(value)+".toString(%s)").removeBraces();
+		
+		addSimpleMapper("CAST_"+fix+"_ARRAY ", type.isObject() ? "("+fix+"_TYPE[])" : "");
+		addSimpleMapper("EMPTY_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])ARRAYS.EMPTY_ARRAY" : "ARRAYS.EMPTY_ARRAY");
+		addInjectMapper("NEW_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])new Object[%s]" : "new "+fix+"_TYPE[%s]").removeBraces();
+		addInjectMapper("NEW_SPECIAL_"+fix+"_ARRAY", type.isObject() ? "(E[])new Object[%s]" : "new "+fix+"_TYPE[%s]").removeBraces();
+		if(value) addInjectMapper("NEW_CLASS_VALUE_ARRAY", type.isObject() ? "(CLASS_VALUE_TYPE[])new Object[%s]" : "new CLASS_VALUE_TYPE[%s]").removeBraces();
+		else addInjectMapper("NEW_CLASS_ARRAY", type.isObject() ? "(CLASS_TYPE[])new Object[%s]" : "new CLASS_TYPE[%s]").removeBraces();
+	}
+}

src/builder/java/speiger/src/builder/modules/ListModule.java

@@ -69,7 +69,10 @@ public class ListModule extends BaseModule
 	protected void loadFunctions()
 	{
 		addFunctionMapper("GET_KEY", "get");
-		addFunctionMapper("REMOVE_LAST", "removeLast");
+		addFunctionMapper("GET_FIRST_KEY", "getFirst");
+		addFunctionMapper("GET_LAST_KEY", "getLast");
+		addFunctionMapper("REMOVE_FIRST_KEY", "removeFirst");
+		addFunctionMapper("REMOVE_LAST_KEY", "removeLast");
 		addFunctionMapper("REMOVE_SWAP", "swapRemove");
 		addFunctionMappers("REPLACE", keyType.isObject() ? "replaceObjects" : "replace%ss");
 		addFunctionMappers("SORT", "sort%ss");

src/builder/java/speiger/src/builder/modules/MapModule.java

@@ -1,282 +1,288 @@
-package speiger.src.builder.modules;
+package speiger.src.builder.modules;
-
+
-import java.util.Arrays;
+import java.util.Arrays;
-import java.util.Set;
+import java.util.Set;
-import java.util.TreeSet;
+import java.util.TreeSet;
-
+
-import speiger.src.builder.ClassType;
+import speiger.src.builder.ClassType;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class MapModule extends BaseModule
+public class MapModule extends BaseModule
-{
+{
-	public static final BaseModule INSTANCE = new MapModule();
+	public static final BaseModule INSTANCE = new MapModule();
-	
+	
-	@Override
+	@Override
-	public String getModuleName() { return "Map"; }
+	public String getModuleName() { return "Map"; }
-	@Override
+	@Override
-	public boolean isBiModule() { return true; }
+	public boolean isBiModule() { return true; }
-	@Override
+	@Override
-	protected void loadVariables() {}
+	protected void loadVariables() {}
-	@Override
+	@Override
-	public boolean isModuleValid(ClassType keyType, ClassType valueType) { return keyType != ClassType.BOOLEAN; }
+	public boolean isModuleValid(ClassType keyType, ClassType valueType) { return keyType != ClassType.BOOLEAN; }
-	@Override
+	@Override
-	public boolean areDependenciesLoaded() { return isDependencyLoaded(SetModule.INSTANCE) && isDependencyLoaded(CollectionModule.INSTANCE, false); }
+	public boolean areDependenciesLoaded() { return isDependencyLoaded(SetModule.INSTANCE) && isDependencyLoaded(CollectionModule.INSTANCE, false); }
-	
+	
-	@Override
+	@Override
-	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) {
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) {
-		Set<String> sets = new TreeSet<>();
+		Set<String> sets = new TreeSet<>();
-		sets.addAll(Arrays.asList("Wrappers", "Implementations"));
+		sets.addAll(Arrays.asList("Wrappers", "Implementations"));
-		sets.addAll(Arrays.asList("OrderedMap", "SortedMap"));
+		sets.addAll(Arrays.asList("OrderedMap", "SortedMap"));
-		sets.addAll(Arrays.asList("ArrayMap", "ConcurrentMap", "ImmutableMap"));
+		sets.addAll(Arrays.asList("ArrayMap", "ConcurrentMap", "ImmutableMap"));
-		sets.addAll(Arrays.asList("HashMap", "LinkedHashMap"));
+		sets.addAll(Arrays.asList("HashMap", "LinkedHashMap"));
-		sets.addAll(Arrays.asList("CustomHashMap", "LinkedCustomHashMap"));
+		sets.addAll(Arrays.asList("CustomHashMap", "LinkedCustomHashMap"));
-		sets.addAll(Arrays.asList("EnumMap", "LinkedEnumMap"));
+		sets.addAll(Arrays.asList("EnumMap", "LinkedEnumMap"));
-		sets.addAll(Arrays.asList("AVLTreeMap", "RBTreeMap"));
+		sets.addAll(Arrays.asList("AVLTreeMap", "RBTreeMap"));
-		return sets;
+		return sets;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	protected void loadFlags()
+	protected void loadFlags()
-	{
+	{
-		if(isModuleEnabled()) addFlag("MAP_MODULE");
+		if(isModuleEnabled()) addFlag("MAP_MODULE");
-		if(isModuleEnabled("Wrappers")) addFlag("MAPS_FEATURE");
+		if(isModuleEnabled("Wrappers")) addFlag("MAPS_FEATURE");
-		boolean implementations = isModuleEnabled("Implementations");
+		boolean implementations = isModuleEnabled("Implementations");
-		boolean hashMap = implementations && isModuleEnabled("HashMap");
+		boolean hashMap = implementations && isModuleEnabled("HashMap");
-		boolean customHashMap = implementations && isModuleEnabled("CustomHashMap");
+		boolean customHashMap = implementations && isModuleEnabled("CustomHashMap");
-		boolean enumMap = implementations && isModuleEnabled("EnumMap");
+		boolean enumMap = implementations && isModuleEnabled("EnumMap");
-		
+		
-		if(isModuleEnabled("OrderedMap")) {
+		if(isModuleEnabled("OrderedMap")) {
-			addFlag("ORDERED_MAP_FEATURE");
+			addFlag("ORDERED_MAP_FEATURE");
-			if(isModuleEnabled("ArrayMap")) addFlag("ARRAY_MAP_FEATURE");
+			if(isModuleEnabled("ArrayMap")) addFlag("ARRAY_MAP_FEATURE");
-			if(hashMap && isModuleEnabled("LinkedHashMap")) addFlag("LINKED_MAP_FEATURE");
+			if(hashMap && isModuleEnabled("LinkedHashMap")) addFlag("LINKED_MAP_FEATURE");
-			if(customHashMap && isModuleEnabled("LinkedCustomHashMap")) addFlag("LINKED_CUSTOM_MAP_FEATURE");
+			if(customHashMap && isModuleEnabled("LinkedCustomHashMap")) addFlag("LINKED_CUSTOM_MAP_FEATURE");
-			if(enumMap && isModuleEnabled("LinkedEnumMap")) addFlag("LINKED_ENUM_MAP_FEATURE");
+			if(enumMap && isModuleEnabled("LinkedEnumMap")) addFlag("LINKED_ENUM_MAP_FEATURE");
-		}
+		}
-		if(isModuleEnabled("SortedMap")) {
+		if(isModuleEnabled("SortedMap")) {
-			addFlag("SORTED_MAP_FEATURE");
+			addFlag("SORTED_MAP_FEATURE");
-			if(implementations && isModuleEnabled("AVLTreeMap")) addFlag("AVL_TREE_MAP_FEATURE");
+			if(implementations && isModuleEnabled("AVLTreeMap")) addFlag("AVL_TREE_MAP_FEATURE");
-			if(implementations && isModuleEnabled("RBTreeMap")) addFlag("RB_TREE_MAP_FEATURE");
+			if(implementations && isModuleEnabled("RBTreeMap")) addFlag("RB_TREE_MAP_FEATURE");
-		}
+		}
-		if(implementations && isModuleEnabled("ConcurrentMap")) addFlag("CONCURRENT_MAP_FEATURE");
+		if(implementations && isModuleEnabled("ConcurrentMap")) addFlag("CONCURRENT_MAP_FEATURE");
-		if(implementations && isModuleEnabled("ImmutableMap")) addFlag("IMMUTABLE_MAP_FEATURE");
+		if(implementations && isModuleEnabled("ImmutableMap")) addFlag("IMMUTABLE_MAP_FEATURE");
-		if(hashMap) addFlag("HASH_MAP_FEATURE");
+		if(hashMap) addFlag("MAP_FEATURE");
-		if(customHashMap) addFlag("CUSTOM_HASH_MAP_FEATURE");
+		if(customHashMap) addFlag("CUSTOM_MAP_FEATURE");
-		if(enumMap) addFlag("ENUM_MAP_FEATURE");
+		if(enumMap) addFlag("ENUM_MAP_FEATURE");
-	}
+	}
-	
+	
-	@Override
+	@Override
-	protected void loadBlockades()
+	protected void loadBlockades()
-	{
+	{
-		if(!isModuleEnabled()) addBlockedFiles("Map", "AbstractMap");
+		if(!isModuleEnabled()) addBlockedFiles("Map", "AbstractMap");
-		if(!isModuleEnabled("Wrappers")) addBlockedFiles("Maps");
+		if(!isModuleEnabled("Wrappers")) addBlockedFiles("Maps");
-		boolean implementations = !isModuleEnabled("Implementations");
+		boolean implementations = !isModuleEnabled("Implementations");
-		if(implementations || !isModuleEnabled("ImmutableMap")) addBlockedFiles("ImmutableOpenHashMap");
+		if(implementations || !isModuleEnabled("ImmutableMap")) addBlockedFiles("ImmutableOpenHashMap");
-		if(implementations || !isModuleEnabled("ConcurrentMap")) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
+		if(implementations || !isModuleEnabled("ConcurrentMap")) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
-		
+		
-		boolean ordered = !isModuleEnabled("OrderedMap");
+		boolean ordered = !isModuleEnabled("OrderedMap");
-		if(ordered) addBlockedFiles("OrderedMap");
+		if(ordered) addBlockedFiles("OrderedMap");
-		boolean hashMap = implementations || !isModuleEnabled("HashMap");
+		boolean hashMap = implementations || !isModuleEnabled("HashMap");
-		if(hashMap) addBlockedFiles("OpenHashMap");
+		if(hashMap) addBlockedFiles("OpenHashMap");
-		if(hashMap || ordered || !isModuleEnabled("LinkedHashMap")) addBlockedFiles("LinkedOpenHashMap");
+		if(hashMap || ordered || !isModuleEnabled("LinkedHashMap")) addBlockedFiles("LinkedOpenHashMap");
-		
+		
-		boolean customHashMap = implementations || !isModuleEnabled("CustomHashMap");
+		boolean customHashMap = implementations || !isModuleEnabled("CustomHashMap");
-		if(customHashMap) addBlockedFiles("OpenCustomHashMap");
+		if(customHashMap) addBlockedFiles("OpenCustomHashMap");
-		if(customHashMap || ordered || !isModuleEnabled("LinkedCustomHashMap")) addBlockedFiles("LinkedOpenCustomHashMap");
+		if(customHashMap || ordered || !isModuleEnabled("LinkedCustomHashMap")) addBlockedFiles("LinkedOpenCustomHashMap");
-		
+		
-		boolean enumMap = implementations || !isModuleEnabled("EnumMap");
+		boolean enumMap = implementations || !isModuleEnabled("EnumMap");
-		if(enumMap) addBlockedFiles("EnumMap");
+		if(enumMap) addBlockedFiles("EnumMap");
-		if(enumMap || ordered || !isModuleEnabled("LinkedEnumMap")) addBlockedFiles("LinkedEnumMap");
+		if(enumMap || ordered || !isModuleEnabled("LinkedEnumMap")) addBlockedFiles("LinkedEnumMap");
-		
+		
-		if(ordered || !isModuleEnabled("ArrayMap")) addBlockedFiles("ArrayMap");
+		if(ordered || !isModuleEnabled("ArrayMap")) addBlockedFiles("ArrayMap");
-		
+		
-		boolean sorted = !isModuleEnabled("SortedMap");
+		boolean sorted = !isModuleEnabled("SortedMap");
-		if(sorted) addBlockedFiles("SortedMap", "NavigableMap");
+		if(sorted) addBlockedFiles("SortedMap", "NavigableMap");
-		if(implementations || sorted || !isModuleEnabled("AVLTreeMap")) addBlockedFiles("AVLTreeMap");
+		if(implementations || sorted || !isModuleEnabled("AVLTreeMap")) addBlockedFiles("AVLTreeMap");
-		if(implementations || sorted || !isModuleEnabled("RBTreeMap")) addBlockedFiles("RBTreeMap");
+		if(implementations || sorted || !isModuleEnabled("RBTreeMap")) addBlockedFiles("RBTreeMap");
-		
+		
-		if(keyType == ClassType.BOOLEAN)
+		if(keyType == ClassType.BOOLEAN)
-		{
+		{
-			//Main Classes
+			//Main Classes
-			addBlockedFiles("SortedMap", "NavigableMap", "RBTreeMap", "AVLTreeMap");
+			addBlockedFiles("SortedMap", "NavigableMap", "RBTreeMap", "AVLTreeMap");
-			addBlockedFiles("OrderedMap", "ArrayMap", "LinkedOpenHashMap", "LinkedOpenCustomHashMap");
+			addBlockedFiles("OrderedMap", "ArrayMap", "LinkedOpenHashMap", "LinkedOpenCustomHashMap");
-			addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
+			addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
-			addBlockedFiles("Map", "Maps", "AbstractMap", "ImmutableOpenHashMap", "OpenHashMap", "OpenCustomHashMap");
+			addBlockedFiles("Map", "Maps", "AbstractMap", "ImmutableOpenHashMap", "OpenHashMap", "OpenCustomHashMap");
-			
+			
-			//Test Classes
+			//Test Classes
-			addBlockedFiles("TestMap", "MapTests", "MapTestSuiteBuilder", "MapConstructorTests", "TestMapGenerator", "SimpleMapTestGenerator", "DerivedMapGenerators", "AbstractMapTester");
+			addBlockedFiles("TestMap", "MapTests", "MapTestSuiteBuilder", "MapConstructorTests", "TestMapGenerator", "SimpleMapTestGenerator", "DerivedMapGenerators", "AbstractMapTester");
-			addBlockedFiles("TestSortedMapGenerator", "NavigableMapTestSuiteBuilder", "SortedMapTestSuiteBuilder");
+			addBlockedFiles("TestSortedMapGenerator", "OrderedMapTestSuiteBuilder", "NavigableMapTestSuiteBuilder", "SortedMapTestSuiteBuilder");
-			addBlockedFiles("TestOrderedMapGenerator");
+			addBlockedFiles("TestOrderedMapGenerator");
-			addBlockedFilter(T -> T.endsWith("Tester") && (T.startsWith("Map") || T.startsWith("OrderedMap") || T.startsWith("SortedMap") || T.startsWith("NavigableMap")));
+			addBlockedFilter(T -> T.endsWith("Tester") && (T.startsWith("Map") || T.startsWith("OrderedMap") || T.startsWith("SortedMap") || T.startsWith("NavigableMap")));
-		}
+		}
-	}
+		if(valueType == ClassType.OBJECT) {
-	
+			addBlockedFiles("MapComputeIfAbsentNonDefaultTester", "MapComputeIfPresentNonDefaultTester", "MapComputeNonDefaultTester", "MapSupplyIfAbsentNonDefaultTester");
-	@Override
+		}
-	protected void loadRemappers()
+	}
-	{
+	
-		//Main Classes
+	@Override
-		addBiRequirement("Map");
+	protected void loadRemappers()
-		addBiRequirement("SortedMap");
+	{
-		addBiRequirement("OrderedMap");
+		//Main Classes
-		addBiRequirement("NavigableMap");
+		addBiRequirement("Map");
-		addBiRequirement("ConcurrentMap");
+		addBiRequirement("SortedMap");
-		addBiRequirement("AbstractMap");
+		addBiRequirement("OrderedMap");
-		addEnumRequirement("EnumMap");
+		addBiRequirement("NavigableMap");
-		addEnumRequirement("LinkedEnumMap");
+		addBiRequirement("ConcurrentMap");
-		addBiRequirement("ConcurrentOpenHashMap");
+		addBiRequirement("AbstractMap");
-		addBiRequirement("ImmutableOpenHashMap");
+		addEnumRequirement("EnumMap");
-		addBiRequirement("OpenHashMap");
+		addEnumRequirement("LinkedEnumMap");
-		addBiRequirement("LinkedOpenHashMap");
+		addBiRequirement("ConcurrentOpenHashMap");
-		addBiRequirement("OpenCustomHashMap");
+		addBiRequirement("ImmutableOpenHashMap");
-		addBiRequirement("LinkedOpenCustomHashMap");
+		addBiRequirement("OpenHashMap");
-		addBiRequirement("ArrayMap");
+		addBiRequirement("LinkedOpenHashMap");
-		addBiRequirement("RBTreeMap");
+		addBiRequirement("OpenCustomHashMap");
-		addBiRequirement("AVLTreeMap");
+		addBiRequirement("LinkedOpenCustomHashMap");
-		addBiRequirement("Maps");
+		addBiRequirement("ArrayMap");
-		
+		addBiRequirement("RBTreeMap");
-		addRemapper("AbstractMap", "Abstract%sMap");
+		addBiRequirement("AVLTreeMap");
-		addRemapper("EnumMap", "Enum2%sMap");
+		addBiRequirement("Maps");
-		addRemapper("LinkedEnumMap", "LinkedEnum2%sMap");
+		
-		addRemapper("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
+		addRemapper("AbstractMap", "Abstract%sMap");
-		
+		addRemapper("EnumMap", "Enum2%sMap");
-		//Test Classes
+		addRemapper("LinkedEnumMap", "LinkedEnum2%sMap");
-		addBiRequirement("TestMapGenerator");
+		addRemapper("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
-		addBiRequirement("TestSortedMapGenerator");
+		
-		addBiRequirement("TestOrderedMapGenerator");
+		//Test Classes
-		addBiRequirement("SimpleMapTestGenerator");
+		addBiRequirement("TestMapGenerator");
-		addBiRequirement("DerivedMapGenerators");
+		addBiRequirement("TestSortedMapGenerator");
-		addBiRequirement("AbstractMapTester");
+		addBiRequirement("TestOrderedMapGenerator");
-		addBiRequirement("MapTestSuiteBuilder");
+		addBiRequirement("SimpleMapTestGenerator");
-		addBiRequirement("SortedMapTestSuiteBuilder");
+		addBiRequirement("DerivedMapGenerators");
-		addBiRequirement("NavigableMapTestSuiteBuilder");
+		addBiRequirement("AbstractMapTester");
-		addBiRequirement("OrderedMapTestSuiteBuilder");
+		addBiRequirement("MapTestSuiteBuilder");
-		addBiRequirement("MapTests");
+		addBiRequirement("SortedMapTestSuiteBuilder");
-		addBiRequirement("MapConstructorTests");
+		addBiRequirement("NavigableMapTestSuiteBuilder");
-		addBiRequirement("TestMap");
+		addBiRequirement("OrderedMapTestSuiteBuilder");
-		addBiRequirement("MapAddToTester");
+		addBiRequirement("MapTests");
-		addBiRequirement("MapSubFromTester");
+		addBiRequirement("MapConstructorTests");
-		addBiRequirement("MapClearTester");
+		addBiRequirement("TestMap");
-		addBiRequirement("MapComputeIfAbsentTester");
+		addBiRequirement("MapAddToTester");
-		addBiRequirement("MapComputeIfPresentTester");
+		addBiRequirement("MapSubFromTester");
-		addBiRequirement("MapComputeTester");
+		addBiRequirement("MapClearTester");
-		addBiRequirement("MapCopyTester");
+		addBiRequirement("MapComputeIfAbsentTester");
-		addBiRequirement("MapContainsTester");
+		addBiRequirement("MapComputeIfPresentTester");
-		addBiRequirement("MapContainsKeyTester");
+		addBiRequirement("MapComputeTester");
-		addBiRequirement("MapContainsValueTester");
+		addBiRequirement("MapComputeIfAbsentNonDefaultTester");
-		addBiRequirement("MapCreatorTester");
+		addBiRequirement("MapComputeIfPresentNonDefaultTester");
-		addBiRequirement("MapEntrySetTester");
+		addBiRequirement("MapComputeNonDefaultTester");
-		addBiRequirement("MapEqualsTester");
+		addBiRequirement("MapCopyTester");
-		addBiRequirement("MapForEachTester");
+		addBiRequirement("MapContainsTester");
-		addBiRequirement("MapGetOrDefaultTester");
+		addBiRequirement("MapContainsKeyTester");
-		addBiRequirement("MapGetTester");
+		addBiRequirement("MapContainsValueTester");
-		addBiRequirement("MapHashCodeTester");
+		addBiRequirement("MapCreatorTester");
-		addBiRequirement("MapIsEmptyTester");
+		addBiRequirement("MapEntrySetTester");
-		addBiRequirement("MapMergeTester");
+		addBiRequirement("MapEqualsTester");
-		addBiRequirement("MapMergeBulkTester");
+		addBiRequirement("MapForEachTester");
-		addBiRequirement("MapPutAllArrayTester");
+		addBiRequirement("MapGetOrDefaultTester");
-		addBiRequirement("MapPutAllTester");
+		addBiRequirement("MapGetTester");
-		addBiRequirement("MapPutIfAbsentTester");
+		addBiRequirement("MapHashCodeTester");
-		addBiRequirement("MapPutTester");
+		addBiRequirement("MapIsEmptyTester");
-		addBiRequirement("MapRemoveEntryTester");
+		addBiRequirement("MapMergeTester");
-		addBiRequirement("MapRemoveOrDefaultTester");
+		addBiRequirement("MapMergeBulkTester");
-		addBiRequirement("MapRemoveTester");
+		addBiRequirement("MapPutAllArrayTester");
-		addBiRequirement("MapReplaceAllTester");
+		addBiRequirement("MapPutAllTester");
-		addBiRequirement("MapReplaceEntryTester");
+		addBiRequirement("MapPutIfAbsentTester");
-		addBiRequirement("MapReplaceTester");
+		addBiRequirement("MapPutTester");
-		addBiRequirement("MapSizeTester");
+		addBiRequirement("MapRemoveEntryTester");
-		addBiRequirement("MapSupplyIfAbsentTester");
+		addBiRequirement("MapRemoveOrDefaultTester");
-		addBiRequirement("MapToStringTester");
+		addBiRequirement("MapRemoveTester");
-		addBiRequirement("NavigableMapNavigationTester");
+		addBiRequirement("MapReplaceAllTester");
-		addBiRequirement("SortedMapNavigationTester");
+		addBiRequirement("MapReplaceEntryTester");
-		addBiRequirement("OrderedMapNavigationTester");
+		addBiRequirement("MapReplaceTester");
-		addBiRequirement("OrderedMapMoveTester");
+		addBiRequirement("MapSizeTester");
-		addBiRequirement("MapConstructorTester");
+		addBiRequirement("MapSupplyIfAbsentTester");
-		
+		addBiRequirement("MapSupplyIfAbsentNonDefaultTester");
-		addRemapper("TestMapGenerator", "Test%sMapGenerator");
+		addBiRequirement("MapToStringTester");
-		addRemapper("TestSortedMapGenerator", "Test%sSortedMapGenerator");
+		addBiRequirement("NavigableMapNavigationTester");
-		addRemapper("TestOrderedMapGenerator", "Test%sOrderedMapGenerator");
+		addBiRequirement("SortedMapNavigationTester");
-		addRemapper("SimpleMapTestGenerator", "Simple%sMapTestGenerator");
+		addBiRequirement("OrderedMapNavigationTester");
-		addRemapper("DerivedMapGenerators", "Derived%sMapGenerators");
+		addBiRequirement("OrderedMapMoveTester");
-		addRemapper("AbstractMapTester", "Abstract%sMapTester");
+		addBiRequirement("MapConstructorTester");
-		addRemapper("TestMap", "Test%sMap");
+		
-	}
+		addRemapper("TestMapGenerator", "Test%sMapGenerator");
-	
+		addRemapper("TestSortedMapGenerator", "Test%sSortedMapGenerator");
-	@Override
+		addRemapper("TestOrderedMapGenerator", "Test%sOrderedMapGenerator");
-	protected void loadFunctions()
+		addRemapper("SimpleMapTestGenerator", "Simple%sMapTestGenerator");
-	{
+		addRemapper("DerivedMapGenerators", "Derived%sMapGenerators");
-		addFunctionValueMapper("BULK_MERGE", "mergeAll");
+		addRemapper("AbstractMapTester", "Abstract%sMapTester");
-		addFunctionValueMappers("COMPUTE_IF_ABSENT", "compute%sIfAbsent");
+		addRemapper("TestMap", "Test%sMap");
-		addFunctionValueMappers("COMPUTE_IF_PRESENT", "compute%sIfPresent");
+	}
-		addFunctionValueMapper("COMPUTE", "compute");
+	
-		addFunctionMapper("DEQUEUE_LAST", "dequeueLast");
+	@Override
-		addFunctionMapper("DEQUEUE", "dequeue");
+	protected void loadFunctions()
-		addSimpleMapper("ENTRY_SET", keyType.getFileType().toLowerCase()+"2"+valueType.getFileType()+"EntrySet");
+	{
-		addFunctionMappers("FIRST_ENTRY_KEY", "first%sKey");
+		addFunctionValueMapper("BULK_MERGE", "mergeAll");
-		addFunctionValueMappers("FIRST_ENTRY_VALUE", "first%sValue");
+		addFunctionValueMappers("COMPUTE_IF_ABSENT", "compute%sIfAbsent");
-		if(keyType.isObject()) addFunctionValueMapper("GET_VALUE", valueType.isObject() ? "getObject" : "get");
+		addFunctionValueMappers("COMPUTE_IF_PRESENT", "compute%sIfPresent");
-		else addSimpleMapper("GET_VALUE", "get");
+		addFunctionValueMapper("COMPUTE", "compute");
-		addSimpleMapper("GET_JAVA", keyType.isObject() ? "get" : "getAs"+keyType.getCustomJDKType().getNonFileType());
+		addFunctionMapper("DEQUEUE_LAST", "dequeueLast");
-		addFunctionMappers("LAST_ENTRY_KEY", "last%sKey");
+		addFunctionMapper("DEQUEUE", "dequeue");
-		addFunctionValueMappers("LAST_ENTRY_VALUE", "last%sValue");
+		addSimpleMapper("ENTRY_SET", keyType.getFileType().toLowerCase()+"2"+valueType.getFileType()+"EntrySet");
-		addFunctionValueMapper("MERGE", "merge");
+		addFunctionMappers("FIRST_ENTRY_KEY", "first%sKey");
-		addFunctionMappers("POLL_FIRST_ENTRY_KEY", "pollFirst%sKey");
+		addFunctionValueMappers("FIRST_ENTRY_VALUE", "first%sValue");
-		addFunctionMappers("POLL_LAST_ENTRY_KEY", "pollLast%sKey");
+		if(keyType.isObject()) addFunctionValueMapper("GET_VALUE", valueType.isObject() ? "getObject" : "get");
-		if(keyType.isObject()) addFunctionMapper("REMOVE_VALUE", "rem");
+		else addSimpleMapper("GET_VALUE", "get");
-		else addSimpleMapper("REMOVE_VALUE", "remove");
+		addFunctionMappers("LAST_ENTRY_KEY", "last%sKey");
-		addFunctionMapper("REMOVE", "remove");
+		addFunctionValueMappers("LAST_ENTRY_VALUE", "last%sValue");
-		addFunctionValueMappers("REPLACE_VALUES", valueType.isObject() ? "replaceObjects" : "replace%ss");
+		addFunctionValueMapper("MERGE", "merge");
-		addFunctionValueMappers("SUPPLY_IF_ABSENT", "supply%sIfAbsent");
+		addFunctionMappers("POLL_FIRST_ENTRY_KEY", "pollFirst%sKey");
-	}
+		addFunctionMappers("POLL_LAST_ENTRY_KEY", "pollLast%sKey");
-	
+		if(keyType.isObject()) addFunctionMapper("REMOVE_VALUE", "rem");
-	@Override
+		else addSimpleMapper("REMOVE_VALUE", "remove");
-	protected void loadClasses()
+		addFunctionMapper("REMOVE", "remove");
-	{
+		addFunctionValueMappers("REPLACE_VALUES", valueType.isObject() ? "replaceObjects" : "replace%ss");
-		//Implementation Classes
+		addFunctionValueMappers("SUPPLY_IF_ABSENT", "supply%sIfAbsent");
-		addAbstractBiMapper("IMMUTABLE_HASH_MAP", "Immutable%sOpenHashMap", "2");
+	}
-		addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
+	
-		addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
+	@Override
-		addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
+	protected void loadClasses()
-		addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
+	{
-		addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
+		//Implementation Classes
-		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
+		addAbstractBiMapper("IMMUTABLE_HASH_MAP", "Immutable%sOpenHashMap", "2");
-		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
+		addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
-		addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
+		addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
-		addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
+		addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
-		addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
+		addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
-		
+		addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
-		//Abstract Classes
+		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
-		addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
+		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
-		
+		addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
-		//Helper Classes
+		addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
-		addBiClassMapper("MAPS", "Maps", "2");
+		addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
-		
+		
-		//Interfaces
+		//Abstract Classes
-		addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
+		addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
-		addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
+		
-		addBiClassMapper("SORTED_MAP", "SortedMap", "2");
+		//Helper Classes
-		addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
+		addBiClassMapper("MAPS", "Maps", "2");
-		addBiClassMapper("MAP", "Map", "2");
+		
-	}
+		//Interfaces
-	
+		addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
-	@Override
+		addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
-	protected void loadTestClasses()
+		addBiClassMapper("SORTED_MAP", "SortedMap", "2");
-	{
+		addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
-		//Implementation Classes
+		addBiClassMapper("MAP", "Map", "2");
-		addAbstractBiMapper("SIMPLE_TEST_MAP", "Test%sMap", "2");
+	}
-		addBiClassMapper("MAP_TESTS", "MapTests", "2");
+	
-		addAbstractBiMapper("NAVIGABLE_MAP_TEST_BUILDER", "%sNavigableMapTestSuiteBuilder", "2");
+	@Override
-		addAbstractBiMapper("SORTED_MAP_TEST_BUILDER", "%sSortedMapTestSuiteBuilder", "2");
+	protected void loadTestClasses()
-		addAbstractBiMapper("ORDERED_MAP_TEST_BUILDER", "%sOrderedMapTestSuiteBuilder", "2");
+	{
-		addAbstractBiMapper("MAP_TEST_BUILDER", "%sMapTestSuiteBuilder", "2");
+		//Implementation Classes
-		
+		addAbstractBiMapper("SIMPLE_TEST_MAP", "Test%sMap", "2");
-		//Abstract Classes
+		addBiClassMapper("MAP_TESTS", "MapTests", "2");
-		addAbstractBiMapper("ABSTRACT_MAP_TESTER", "Abstract%sMapTester", "2");
+		addAbstractBiMapper("NAVIGABLE_MAP_TEST_BUILDER", "%sNavigableMapTestSuiteBuilder", "2");
-		
+		addAbstractBiMapper("SORTED_MAP_TEST_BUILDER", "%sSortedMapTestSuiteBuilder", "2");
-		//Helper Classes
+		addAbstractBiMapper("ORDERED_MAP_TEST_BUILDER", "%sOrderedMapTestSuiteBuilder", "2");
-		addAbstractBiMapper("MAP_CONSTRUCTOR_TESTS", "%sMapConstructorTests", "2");
+		addAbstractBiMapper("MAP_TEST_BUILDER", "%sMapTestSuiteBuilder", "2");
-		addAbstractBiMapper("SIMPLE_MAP_TEST_GENERATOR", "Simple%sMapTestGenerator", "2");
+		
-		addAbstractBiMapper("DERIVED_MAP_GENERATORS", "Derived%sMapGenerators", "2");
+		//Abstract Classes
-		addAbstractBiMapper("TEST_ORDERED_MAP_GENERATOR", "Test%sOrderedMapGenerator", "2");
+		addAbstractBiMapper("ABSTRACT_MAP_TESTER", "Abstract%sMapTester", "2");
-		addAbstractBiMapper("TEST_SORTED_MAP_GENERATOR", "Test%sSortedMapGenerator", "2");
+		
-		addAbstractBiMapper("TEST_MAP_GENERATOR", "Test%sMapGenerator", "2");
+		//Helper Classes
-	}
+		addAbstractBiMapper("MAP_CONSTRUCTOR_TESTS", "%sMapConstructorTests", "2");
+		addAbstractBiMapper("SIMPLE_MAP_TEST_GENERATOR", "Simple%sMapTestGenerator", "2");
+		addAbstractBiMapper("DERIVED_MAP_GENERATORS", "Derived%sMapGenerators", "2");
+		addAbstractBiMapper("TEST_ORDERED_MAP_GENERATOR", "Test%sOrderedMapGenerator", "2");
+		addAbstractBiMapper("TEST_SORTED_MAP_GENERATOR", "Test%sSortedMapGenerator", "2");
+		addAbstractBiMapper("TEST_MAP_GENERATOR", "Test%sMapGenerator", "2");
+	}
 }

src/builder/java/speiger/src/builder/modules/SetModule.java

@@ -90,10 +90,11 @@ public class SetModule extends BaseModule
 			addBlockedFiles("Set", "Sets", "AbstractSet", "OpenHashSet", "OpenCustomHashSet", "ImmutableOpenHashSet");
 			
 			//Test Classes
-			addBlockedFiles("SetTests", "SetTestSuiteBuilder");
+			addBlockedFiles("SetTests", "SetTestSuiteBuilder", "TestSetGenerator");
 			addBlockedFiles("OrderedSetTestSuiteBuilder", "TestOrderedSetGenerator", "OrderedSetMoveTester", "OrderedSetNavigationTester", "OrderedSetIterationTester");
 			addBlockedFiles("SortedSetTestSuiteBuilder", "TestSortedSetGenerator", "SortedSetNaviationTester", "SortedSetSubsetTestSetGenerator", "SortedSetIterationTester", "SortedSetNaviationTester");
 			addBlockedFiles("NavigableSetTestSuiteBuilder", "TestNavigableSetGenerator", "NavigableSetNavigationTester");
+			addBlockedFiles("MinimalSet", "AbstractSetTester", "SetAddAllTester", "SetAddTester", "SetCreationTester", "SetEqualsTester", "SetRemoveTester");
 		}
 	}
 	
@@ -119,7 +120,7 @@ public class SetModule extends BaseModule
 		addFunctionMapper("POLL_FIRST_KEY", "pollFirst");
 		addFunctionMapper("POLL_LAST_KEY", "pollLast");
 		addFunctionMapper("FIRST_KEY", "first");
-		addFunctionMapper("LAST_KEY", "last");
+		addFunctionMapper("LAST_KEY", "last");	
 	}
 	
 	@Override

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

@@ -1,264 +1,266 @@
-package speiger.src.collections.PACKAGE.collections;
+package speiger.src.collections.PACKAGE.collections;
-
+
-import java.util.Collection;
+import java.util.Collection;
-import java.util.Objects;
+import java.util.Objects;
-import java.util.AbstractCollection;
+import java.util.AbstractCollection;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-#endif
+#endif
-
+
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
-import speiger.src.collections.PACKAGE.utils.ITERATORS;
+import speiger.src.collections.PACKAGE.utils.ITERATORS;
-#endif
+import speiger.src.collections.PACKAGE.utils.ARRAYS;
-
+#endif
-/**
+
- * Abstract Type Specific Collection that reduces boxing/unboxing
+/**
- * @Type(T)
+ * Abstract Type Specific Collection that reduces boxing/unboxing
- */
+ * @Type(T)
-public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractCollection<CLASS_TYPE> implements COLLECTION KEY_GENERIC_TYPE
+ */
-{
+public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractCollection<CLASS_TYPE> implements COLLECTION KEY_GENERIC_TYPE
-	@Override
+{
-	public abstract ITERATOR KEY_GENERIC_TYPE iterator();
+	@Override
-	
+	public abstract ITERATOR KEY_GENERIC_TYPE iterator();
-#if !TYPE_OBJECT
+	
-	/** {@inheritDoc}
+#if !TYPE_OBJECT
-	 * <p>This default implementation delegates to the corresponding type-specific function.
+	/** {@inheritDoc}
-	 * @deprecated Please use the corresponding type-specific function instead. 
+	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 */
+	 * @deprecated Please use the corresponding type-specific function instead. 
-	@Override
+	 */
-	@Deprecated
+	@Override
-	public boolean add(CLASS_TYPE e) { return COLLECTION.super.add(e); }
+	@Deprecated
-
+	public boolean add(CLASS_TYPE e) { return COLLECTION.super.add(e); }
-#endif
+
-	@Override
+#endif
-	public boolean addAll(COLLECTION KEY_GENERIC_TYPE c) {
+	@Override
-		boolean modified = false;
+	public boolean addAll(COLLECTION KEY_GENERIC_TYPE c) {
-		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();modified |= add(iter.NEXT()));
+		boolean modified = false;
-		return modified;
+		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();modified |= add(iter.NEXT()));
-	}
+		return modified;
-	
+	}
-	@Override
+	
-	public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+	@Override
-	
+	public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
-#if !TYPE_OBJECT
+	
-	/** {@inheritDoc}
+#if !TYPE_OBJECT
-	 * <p>This default implementation delegates to the corresponding type-specific function.
+	/** {@inheritDoc}
-	 * @deprecated Please use the corresponding type-specific function instead. 
+	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 */
+	 * @deprecated Please use the corresponding type-specific function instead. 
-	@Override
+	 */
-	@Deprecated
+	@Override
-	public boolean contains(Object e) { return COLLECTION.super.contains(e); }
+	@Deprecated
-	
+	public boolean contains(Object e) { return COLLECTION.super.contains(e); }
-	/**
+	
-	 * A Type-Specific implementation of contains. This implementation iterates over the elements and returns true if the value match.
+	/**
-	 * @param e the element that should be searched for.
+	 * A Type-Specific implementation of contains. This implementation iterates over the elements and returns true if the value match.
-	 * @return true if the value was found.
+	 * @param e the element that should be searched for.
-	 */
+	 * @return true if the value was found.
-	@Override
+	 */
-	public boolean contains(KEY_TYPE e) {
+	@Override
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) { if(KEY_EQUALS(iter.NEXT(), e)) return true; }
+	public boolean contains(KEY_TYPE e) {
-		return false;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) { if(KEY_EQUALS(iter.NEXT(), e)) return true; }
-	}
+		return false;
-	
+	}
-	/** {@inheritDoc}
+	
-	 * <p>This default implementation delegates to the corresponding type-specific function.
+	/** {@inheritDoc}
-	 * @deprecated Please use the corresponding type-specific function instead. 
+	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 */
+	 * @deprecated Please use the corresponding type-specific function instead. 
-	@Override
+	 */
-	@Deprecated
+	@Override
-	public boolean addAll(Collection<? extends CLASS_TYPE> c)
+	@Deprecated
-	{
+	public boolean addAll(Collection<? extends CLASS_TYPE> c)
-		return c instanceof COLLECTION ? addAll((COLLECTION KEY_GENERIC_TYPE)c) : super.addAll(c);
+	{
-	}
+		return c instanceof COLLECTION ? addAll((COLLECTION KEY_GENERIC_TYPE)c) : super.addAll(c);
-#endif
+	}
-	
+#endif
-	/**
+	
-	 * A Type-Specific implementation of containsAll. This implementation iterates over all elements and checks all elements are present in the other collection.
+	/**
-	 * @param c the collection that should be checked if it contains all elements.
+	 * A Type-Specific implementation of containsAll. This implementation iterates over all elements and checks all elements are present in the other collection.
-	 * @return true if all elements were found in the collection
+	 * @param c the collection that should be checked if it contains all elements.
-	 * @throws java.lang.NullPointerException if the collection is null
+	 * @return true if all elements were found in the collection
-	 */
+	 * @throws java.lang.NullPointerException if the collection is null
-	@Override
+	 */
-	public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c) {
+	@Override
-		Objects.requireNonNull(c);
+	public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c) {
-		if(c.isEmpty()) return true;
+		Objects.requireNonNull(c);
-		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
+		if(c.isEmpty()) return true;
-			if(!contains(iter.NEXT()))
+		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
-				return false;
+			if(!contains(iter.NEXT()))
-		return true;
+				return false;
-	}
+		return true;
-	
+	}
-	@Override
+	
-	public boolean containsAll(Collection<?> c) {
+	@Override
-		Objects.requireNonNull(c);
+	public boolean containsAll(Collection<?> c) {
-		return c instanceof COLLECTION ? containsAll((COLLECTION KEY_GENERIC_TYPE)c) : super.containsAll(c);
+		Objects.requireNonNull(c);
-	}
+		return c instanceof COLLECTION ? containsAll((COLLECTION KEY_GENERIC_TYPE)c) : super.containsAll(c);
-	
+	}
-	/**
+	
-	 * This implementation iterates over the elements of the collection and checks if they are stored in this collection
+	/**
-	 * @param c the elements that should be checked for
+	 * This implementation iterates over the elements of the collection and checks if they are stored in this collection
-	 * @return true if any element is in this collection
+	 * @param c the elements that should be checked for
-	 * @throws java.lang.NullPointerException if the collection is null
+	 * @return true if any element is in this collection
-	 */
+	 * @throws java.lang.NullPointerException if the collection is null
-	@Override
+	 */
-	@Primitive
+	@Override
-	public boolean containsAny(Collection<?> c) {
+	@Primitive
-		Objects.requireNonNull(c);
+	public boolean containsAny(Collection<?> c) {
-		if(c.isEmpty()) return false;
+		Objects.requireNonNull(c);
-		for(Object e : c) 
+		if(c.isEmpty()) return false;
-			if(contains(e))
+		for(Object e : c) 
-				return true;
+			if(contains(e))
-		return false;
+				return true;
-	}
+		return false;
-	
+	}
-	/**
+	
-	 * This implementation iterates over the elements of the collection and checks if they are stored in this collection.
+	/**
-	 * @param c the elements that should be checked for
+	 * This implementation iterates over the elements of the collection and checks if they are stored in this collection.
-	 * @return true if any element is in this collection
+	 * @param c the elements that should be checked for
- 	 * @throws java.lang.NullPointerException if the collection is null
+	 * @return true if any element is in this collection
-	 */
+ 	 * @throws java.lang.NullPointerException if the collection is null
-	@Override
+	 */
-	public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c) {
+	@Override
-		Objects.requireNonNull(c);
+	public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c) {
-		if(c.isEmpty()) return false;
+		Objects.requireNonNull(c);
-		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();) 
+		if(c.isEmpty()) return false;
-			if(contains(iter.NEXT()))
+		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();) 
-				return true;
+			if(contains(iter.NEXT()))
-		return false;
+				return true;
-	}
+		return false;
-		
+	}
-#if !TYPE_OBJECT
+		
-	/** {@inheritDoc}
+#if !TYPE_OBJECT
-	 * <p>This default implementation delegates to the corresponding type-specific function.
+	/** {@inheritDoc}
-	 * @deprecated Please use the corresponding type-specific function instead. 
+	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 */
+	 * @deprecated Please use the corresponding type-specific function instead. 
-	@Override
+	 */
-	@Deprecated
+	@Override
-	public boolean remove(Object e) { return COLLECTION.super.remove(e); }
+	@Deprecated
-	
+	public boolean remove(Object e) { return COLLECTION.super.remove(e); }
-	/**
+	
-	 * A Type-Specific implementation of remove. This implementation iterates over the elements until it finds the element that is searched for or it runs out of elements.
+	/**
-	 * It stops after finding the first element
+	 * A Type-Specific implementation of remove. This implementation iterates over the elements until it finds the element that is searched for or it runs out of elements.
-	 * @param e the element that is searched for
+	 * It stops after finding the first element
-	 * @return true if the element was found and removed.
+	 * @param e the element that is searched for
-	 */
+	 * @return true if the element was found and removed.
-	@Override
+	 */
-	public boolean REMOVE_KEY(KEY_TYPE e) {
+	@Override
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+	public boolean REMOVE_KEY(KEY_TYPE e) {
-			if(KEY_EQUALS(iter.NEXT(), e)) {
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-				iter.remove();
+			if(KEY_EQUALS(iter.NEXT(), e)) {
-				return true;
+				iter.remove();
-			}
+				return true;
-		}
+			}
-		return false;
+		}
-	}
+		return false;
-	
+	}
-#endif
+	
-	/**
+#endif
-	 * A Type-Specific implementation of removeAll. This Implementation iterates over all elements and removes them as they were found in the other collection.
+	/**
-	 * @param c the elements that should be deleted
+	 * A Type-Specific implementation of removeAll. This Implementation iterates over all elements and removes them as they were found in the other collection.
-	 * @return true if the collection was modified.
+	 * @param c the elements that should be deleted
-	 * @throws java.lang.NullPointerException if the collection is null
+	 * @return true if the collection was modified.
-	 */
+	 * @throws java.lang.NullPointerException if the collection is null
-	@Override
+	 */
-	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) {
+	@Override
-		Objects.requireNonNull(c);
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) {
-		if(c.isEmpty()) return false;
+		Objects.requireNonNull(c);
-		boolean modified = false;
+		if(c.isEmpty()) return false;
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+		boolean modified = false;
-			if(c.contains(iter.NEXT())) {
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-				iter.remove();
+			if(c.contains(iter.NEXT())) {
-				modified = true;
+				iter.remove();
-			}
+				modified = true;
-		}
+			}
-		return modified;
+		}
-	}
+		return modified;
-
+	}
-	@Override
+
-	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+	@Override
-		Objects.requireNonNull(c);
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
-		if(c.isEmpty()) return false;
+		Objects.requireNonNull(c);
-		Objects.requireNonNull(r);
+		if(c.isEmpty()) return false;
-		boolean modified = false;
+		Objects.requireNonNull(r);
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+		boolean modified = false;
-			KEY_TYPE e = iter.NEXT();
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-			if(c.contains(e)) {
+			KEY_TYPE e = iter.NEXT();
-				r.accept(e);
+			if(c.contains(e)) {
-				iter.remove();
+				r.accept(e);
-				modified = true;
+				iter.remove();
-			}
+				modified = true;
-		}
+			}
-		return modified;
+		}
-	}
+		return modified;
-	
+	}
-	/**
+	
-	 * A Type-Specific implementation of retainAll. This Implementation iterates over all elements and removes them as they were not found in the other collection.
+	/**
-	 * @param c the elements that should be kept
+	 * A Type-Specific implementation of retainAll. This Implementation iterates over all elements and removes them as they were not found in the other collection.
-	 * @return true if the collection was modified.
+	 * @param c the elements that should be kept
-	 * @throws java.lang.NullPointerException if the collection is null
+	 * @return true if the collection was modified.
-	 */
+	 * @throws java.lang.NullPointerException if the collection is null
-	@Override
+	 */
-	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) {
+	@Override
-		Objects.requireNonNull(c);
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) {
-		if(c.isEmpty()) {
+		Objects.requireNonNull(c);
-			boolean modified = !isEmpty();
+		if(c.isEmpty()) {
-			clear();
+			boolean modified = !isEmpty();
-			return modified;
+			clear();
-		}
+			return modified;
-		boolean modified = false;
+		}
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+		boolean modified = false;
-			if(!c.contains(iter.NEXT())) {
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-				iter.remove();
+			if(!c.contains(iter.NEXT())) {
-				modified = true;
+				iter.remove();
-			}
+				modified = true;
-		}
+			}
-		return modified;
+		}
-	}
+		return modified;
-	
+	}
-	@Override
+	
-	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+	@Override
-		Objects.requireNonNull(c);
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
-		Objects.requireNonNull(r);
+		Objects.requireNonNull(c);
-		if(c.isEmpty()) {
+		Objects.requireNonNull(r);
-			boolean modified = !isEmpty();
+		if(c.isEmpty()) {
-			forEach(r);
+			boolean modified = !isEmpty();
-			clear();
+			forEach(r);
-			return modified;
+			clear();
-		}
+			return modified;
-		boolean modified = false;
+		}
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+		boolean modified = false;
-			KEY_TYPE e = iter.NEXT();
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-			if(!c.contains(e)) {
+			KEY_TYPE e = iter.NEXT();
-				r.accept(e);
+			if(!c.contains(e)) {
-				iter.remove();
+				r.accept(e);
-				modified = true;
+				iter.remove();
-			}
+				modified = true;
-		}
+			}
-		return modified;
+		}
-	}
+		return modified;
-	
+	}
-#if !TYPE_OBJECT
+	
-	/**
+#if !TYPE_OBJECT
-	 * A Type-Specific implementation of toArray that links to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
+	/**
-	 * @return an array containing all of the elements in this collection
+	 * A Type-Specific implementation of toArray that links to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
-	 */
+	 * @return an array containing all of the elements in this collection
-	@Override
+	 */
-	public KEY_TYPE[] TO_ARRAY() {
+	@Override
-		return TO_ARRAY(new KEY_TYPE[size()]);
+	public KEY_TYPE[] TO_ARRAY() {
-	}
+		if(isEmpty()) return ARRAYS.EMPTY_ARRAY;
-	
+		return TO_ARRAY(new KEY_TYPE[size()]);
-	/**
+	}
-	 * A Type-Specific implementation of toArray. This implementation iterates over all elements and unwraps them into primitive type.
+	
-	 * @param a array that the elements should be injected to. If null or to small a new array with the right size is created
+	/**
-	 * @return an array containing all of the elements in this collection
+	 * A Type-Specific implementation of toArray. This implementation iterates over all elements and unwraps them into primitive type.
-	 */
+	 * @param a array that the elements should be injected to. If null or to small a new array with the right size is created
-	@Override
+	 * @return an array containing all of the elements in this collection
-	public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
+	 */
-		if(a == null || a.length < size()) a = new KEY_TYPE[size()];
+	@Override
-		ITERATORS.unwrap(a, iterator());
+	public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
-		if (a.length > size()) a[size()] = EMPTY_KEY_VALUE;
+		if(a == null || a.length < size()) a = new KEY_TYPE[size()];
-		return a;
+		ITERATORS.unwrap(a, iterator());
-	}
+		if (a.length > size()) a[size()] = EMPTY_KEY_VALUE;
-#endif
+		return a;
+	}
+#endif
 }

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

@@ -1,322 +1,323 @@
-package speiger.src.collections.PACKAGE.collections;
+package speiger.src.collections.PACKAGE.collections;
-
+
-import java.util.Collection;
+import java.util.Collection;
-#if PRIMITIVES
+#if PRIMITIVES
-import java.util.Objects;
+import java.util.Objects;
-import java.util.function.JAVA_PREDICATE;
+import java.util.function.JAVA_PREDICATE;
-import java.util.function.Predicate;
+import java.util.function.Predicate;
-#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-import java.util.stream.JAVA_STREAM;
+import java.util.stream.JAVA_STREAM;
-import java.util.stream.StreamSupport;
+import java.util.stream.StreamSupport;
-#endif
+#endif
-#endif
+#endif
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-import speiger.src.collections.ints.functions.function.Int2ObjectFunction;
+import java.util.function.IntFunction;
-#else
+#else
-import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
-#endif
+#endif
-#if SPLIT_ITERATOR_FEATURE
+#if SPLIT_ITERATOR_FEATURE
-import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
+import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
-#endif
+#endif
-import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
+import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
-import speiger.src.collections.utils.ISizeProvider;
+import speiger.src.collections.utils.ISizeProvider;
-import speiger.src.collections.utils.SanityChecks;
+import speiger.src.collections.utils.SanityChecks;
-
+
-/**
+/**
- * A Type-Specific {@link Collection} that reduces (un)boxing
+ * A Type-Specific {@link Collection} that reduces (un)boxing
- * @Type(T)
+ * @Type(T)
- */
+ */
-public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITERABLE KEY_GENERIC_TYPE, ISizeProvider
+public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITERABLE KEY_GENERIC_TYPE, ISizeProvider
-{
+{
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	/**
+	/**
-	 * A Type-Specific add function to reduce (un)boxing
+	 * A Type-Specific add function to reduce (un)boxing
-	 * @param o the element that should be added
+	 * @param o the element that should be added
-	 * @return true if the element was added to the collection
+	 * @return true if the element was added to the collection
-	 */
+	 */
-	public boolean add(KEY_TYPE o);
+	public boolean add(KEY_TYPE o);
-	
+	
-#endif
+#endif
-	/**
+	/**
-	 * A Type-Specific addAll function to reduce (un)boxing
+	 * A Type-Specific addAll function to reduce (un)boxing
-	 * @param c the collection of elements that should be added
+	 * @param c the collection of elements that should be added
-	 * @return true if elements were added into the collection
+	 * @return true if elements were added into the collection
-	 */
+	 */
-	public boolean addAll(COLLECTION KEY_GENERIC_TYPE c);
+	public boolean addAll(COLLECTION KEY_GENERIC_TYPE c);
-	
+	
-	/**
+	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
+	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
+	 * @param e the elements that should be added
-	 * @return if the collection was modified
+	 * @return if the collection was modified
-	 */
+	 */
-	public default boolean addAll(KEY_TYPE... e) { return addAll(e, 0, e.length); }
+	public default boolean addAll(KEY_TYPE... e) { return addAll(e, 0, e.length); }
-	
+	
-	/**
+	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
+	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
+	 * @param e the elements that should be added
-	 * @param length how many elements of the array should be added
+	 * @param length how many elements of the array should be added
-	 * @return if the collection was modified
+	 * @return if the collection was modified
-	 */
+	 */
-	public default boolean addAll(KEY_TYPE[] e, int length) { return addAll(e, 0, length); }
+	public default boolean addAll(KEY_TYPE[] e, int length) { return addAll(e, 0, length); }
-	
+	
-	/**
+	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
+	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
+	 * @param e the elements that should be added
-	 * @param offset where to start within the array
+	 * @param offset where to start within the array
-	 * @param length how many elements of the array should be added
+	 * @param length how many elements of the array should be added
-	 * @return if the collection was modified
+	 * @return if the collection was modified
-	 */
+	 */
-	public default boolean addAll(KEY_TYPE[] e, int offset, int length) {
+	public default boolean addAll(KEY_TYPE[] e, int offset, int length) {
-		if(length <= 0) return false;
+		if(length <= 0) return false;
-		SanityChecks.checkArrayCapacity(e.length, offset, length);
+		SanityChecks.checkArrayCapacity(e.length, offset, length);
-		boolean added = false;
+		boolean added = false;
-		for(int i = 0;i<length;i++) {
+		for(int i = 0;i<length;i++) {
-			if(add(e[offset+i])) added = true;
+			if(add(e[offset+i])) added = true;
-		}
+		}
-		return added;
+		return added;
-	}
+	}
-	
+	
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	/**
+	/**
-	 * A Type-Specific contains function to reduce (un)boxing
+	 * A Type-Specific contains function to reduce (un)boxing
-	 * @param o the element that is checked for
+	 * @param o the element that is checked for
-	 * @return true if the element is found in the collection
+	 * @return true if the element is found in the collection
-	 */
+	 */
-	public boolean contains(KEY_TYPE o);
+	public boolean contains(KEY_TYPE o);
-	
+	
-#endif
+#endif
-	/**
+	/**
- 	 * A Type-Specific containsAll function to reduce (un)boxing
+ 	 * A Type-Specific containsAll function to reduce (un)boxing
- 	 * @param c the collection of elements that should be tested for
+ 	 * @param c the collection of elements that should be tested for
- 	 * @return true if all the element is found in the collection
+ 	 * @return true if all the element is found in the collection
- 	 */
+ 	 */
-	public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c);
+	public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c);
-	
+	
-	/**
+	/**
-	 * A Type-Specific containsAny function to reduce (un)boxing
+	 * A Type-Specific containsAny function to reduce (un)boxing
- 	 * @param c the collection of elements that should be tested for
+ 	 * @param c the collection of elements that should be tested for
-	 * @return true if any element was found
+	 * @return true if any element was found
-	 */
+	 */
-	public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c);
+	public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c);
-	
+	
-	/**
+	/**
-	 * Returns true if any element of the Collection is found in the provided collection.
+	 * Returns true if any element of the Collection is found in the provided collection.
-	 * A Small Optimization function to find out of any element is present when comparing collections and not all of them.
+	 * A Small Optimization function to find out of any element is present when comparing collections and not all of them.
- 	 * @param c the collection of elements that should be tested for
+ 	 * @param c the collection of elements that should be tested for
-	 * @return true if any element was found.
+	 * @return true if any element was found.
-	 */
+	 */
-	@Primitive
+	@Primitive
-	public boolean containsAny(Collection<?> c);
+	public boolean containsAny(Collection<?> c);
-	
+	
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	/**
+	/**
-	 * A Type-Specific remove function that reduces (un)boxing.
+	 * A Type-Specific remove function that reduces (un)boxing.
-	 * @param o the element that should be removed
+	 * @param o the element that should be removed
-	 * @return true if the element was removed
+	 * @return true if the element was removed
-	 * @see Collection#remove(Object)
+	 * @see Collection#remove(Object)
-	 */
+	 */
-	public boolean REMOVE_KEY(KEY_TYPE o);
+	public boolean REMOVE_KEY(KEY_TYPE o);
-	
+	
-#endif
+#endif
-	/**
+	/**
-	 * A Type-Specific removeAll function that reduces (un)boxing.
+	 * A Type-Specific removeAll function that reduces (un)boxing.
-	 * @param c the collection of elements that should be removed
+	 * @param c the collection of elements that should be removed
-	 * @return true if any element was removed
+	 * @return true if any element was removed
-	 * @see Collection#removeAll(Collection)
+	 * @see Collection#removeAll(Collection)
-	 */
+	 */
-	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c);
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c);
-	
+	
-	/**
+	/**
-	 * A Type-Specific removeAll function that reduces (un)boxing.
+	 * A Type-Specific removeAll function that reduces (un)boxing.
-	 * It also notifies the remover of which exact element is going to be removed.
+	 * It also notifies the remover of which exact element is going to be removed.
-	 * @param c the collection of elements that should be removed
+	 * @param c the collection of elements that should be removed
-	 * @param r elements that got removed
+	 * @param r elements that got removed
-	 * @return true if any element was removed
+	 * @return true if any element was removed
-	 * @see Collection#removeAll(Collection)
+	 * @see Collection#removeAll(Collection)
-	 */
+	 */
-	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
-	
+	
-	/**
+	/**
- 	 * A Type-Specific retainAll function that reduces (un)boxing.
+ 	 * A Type-Specific retainAll function that reduces (un)boxing.
-	 * @param c the collection of elements that should be kept
+	 * @param c the collection of elements that should be kept
- 	 * @return true if any element was removed
+ 	 * @return true if any element was removed
- 	 * @see Collection#retainAll(Collection)
+ 	 * @see Collection#retainAll(Collection)
- 	 */
+ 	 */
-	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c);
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c);
-	
+	
-	/**
+	/**
- 	 * A Type-Specific retainAll function that reduces (un)boxing.
+ 	 * A Type-Specific retainAll function that reduces (un)boxing.
-	 * It also notifies the remover of which exact element is going to be removed.
+	 * It also notifies the remover of which exact element is going to be removed.
-	 * @param c the collection of elements that should be kept
+	 * @param c the collection of elements that should be kept
-	 * @param r elements that got removed
+	 * @param r elements that got removed
- 	 * @return true if any element was removed
+ 	 * @return true if any element was removed
- 	 * @see Collection#retainAll(Collection)
+ 	 * @see Collection#retainAll(Collection)
- 	 */
+ 	 */
-	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
-	
+	
-	/**
+	/**
-	 * A Helper function to reduce the usage of Streams and allows to collect all elements
+	 * A Helper function to reduce the usage of Streams and allows to collect all elements
-	 * @param collection that the elements should be inserted to
+	 * @param collection that the elements should be inserted to
-	 * @param <E> the collection type
+	 * @param <E> the collection type
-	 * @return the input with the desired elements
+	 * @return the input with the desired elements
-	 */
+	 */
-	default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
+	default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
-		collection.addAll(this);
+		collection.addAll(this);
-		return collection;
+		return collection;
-	}
+	}
-	
+	
-	/**
+	/**
-	 * A Function that does a shallow clone of the Collection itself.
+	 * 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.
+	 * 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
+	 * It can be compared to Cloneable but with less exception risk
-	 * @return a Shallow Copy of the collection
+	 * @return a Shallow Copy of the collection
-	 * @note Wrappers and view collections will not support this feature
+	 * @note Wrappers and view collections will not support this feature
-	 */
+	 */
-	public COLLECTION KEY_GENERIC_TYPE copy();
+	public COLLECTION KEY_GENERIC_TYPE copy();
-	
+	
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-	/**
+	/**
-	 * A Helper function that simplifies the process of creating a new Array.
+	 * A Helper function that simplifies the process of creating a new Array.
-	 * @param action the array creation function
+	 * @param action the array creation function
-	 * @return an array containing all of the elements in this collection
+	 * @param <E> the returning arrayType
-	 * @see Collection#toArray(Object[])
+	 * @return an array containing all of the elements in this collection
-	 */
+	 * @see Collection#toArray(Object[])
-	default KEY_TYPE[] TO_ARRAY(Int2ObjectFunction<KEY_TYPE[]> action) {
+	 */
-		return TO_ARRAY(action.apply(size()));
+	default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
-	}
+		return TO_ARRAY(action.apply(size()));
-	
+	}
-#else
+	
-	/**
+#else
-	 * A Type-Specific toArray function that delegates to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
+	/**
-	 * @return an array containing all of the elements in this collection
+	 * A Type-Specific toArray function that delegates to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
-	 * @see Collection#toArray()
+	 * @return an array containing all of the elements in this collection
-	 */
+	 * @see Collection#toArray()
-	public KEY_TYPE[] TO_ARRAY();
+	 */
-	
+	public KEY_TYPE[] TO_ARRAY();
-	/**
+	
-	 * A Type-Specific toArray function that reduces (un)boxing.
+	/**
-	 * @param a array that the elements should be injected to. If null or to small a new array with the right size is created
+	 * A Type-Specific toArray function that reduces (un)boxing.
-	 * @return an array containing all of the elements in this collection
+	 * @param a array that the elements should be injected to. If null or to small a new array with the right size is created
-	 * @see Collection#toArray(Object[])
+	 * @return an array containing all of the elements in this collection
-	 */
+	 * @see Collection#toArray(Object[])
-	public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a);
+	 */
-	
+	public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a);
-#if PRIMITIVES
+	
-	/** {@inheritDoc}
+#if PRIMITIVES
-	 * <p>This default implementation delegates to the corresponding type-specific function.
+	/** {@inheritDoc}
-	 * @deprecated Please use the corresponding type-specific function instead. 
+	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 */
+	 * @deprecated Please use the corresponding type-specific function instead. 
-	@Override
+	 */
-	@Deprecated
+	@Override
-	public default boolean removeIf(Predicate<? super CLASS_TYPE> filter) {
+	@Deprecated
-		Objects.requireNonNull(filter);
+	public default boolean removeIf(Predicate<? super CLASS_TYPE> filter) {
-#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
+		Objects.requireNonNull(filter);
-		return remIf(v -> filter.test(KEY_TO_OBJ(SanityChecks.SANITY_CAST(v))));
+#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
-#else
+		return remIf(v -> filter.test(KEY_TO_OBJ(SanityChecks.SANITY_CAST(v))));
-	return remIf(v -> filter.test(KEY_TO_OBJ(v)));
+#else
-#endif
+	return remIf(v -> filter.test(KEY_TO_OBJ(v)));
-	}
+#endif
-	
+	}
-	/**
+	
-	 * A Type-Specific removeIf function to reduce (un)boxing.
+	/**
-	 * <p>Removes elements that were selected by the filter
+	 * A Type-Specific removeIf function to reduce (un)boxing.
-	 * @see Collection#removeIf(Predicate)
+	 * <p>Removes elements that were selected by the filter
-	 * @param filter Filters the elements that should be removed
+	 * @see Collection#removeIf(Predicate)
-	 * @return true if the collection was modified
+	 * @param filter Filters the elements that should be removed
-	 * @throws java.lang.NullPointerException if filter is null
+	 * @return true if the collection was modified
-	 */
+	 * @throws java.lang.NullPointerException if filter is null
-	public default boolean remIf(JAVA_PREDICATE filter) {
+	 */
-		Objects.requireNonNull(filter);
+	public default boolean remIf(JAVA_PREDICATE filter) {
-		boolean removed = false;
+		Objects.requireNonNull(filter);
-		final ITERATOR each = iterator();
+		boolean removed = false;
-		while (each.hasNext()) {
+		final ITERATOR each = iterator();
-			if (filter.test(each.NEXT())) {
+		while (each.hasNext()) {
-				each.remove();
+			if (filter.test(each.NEXT())) {
-				removed = true;
+				each.remove();
-			}
+				removed = true;
-		}
+			}
-		return removed;
+		}
-	}
+		return removed;
-	
+	}
-#endif
+	
-	/** {@inheritDoc}
+#endif
-	 * <p>This default implementation delegates to the corresponding type-specific function.
+	/** {@inheritDoc}
-	 * @deprecated Please use the corresponding type-specific function instead. 
+	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 */
+	 * @deprecated Please use the corresponding type-specific function instead. 
-	@Override
+	 */
-	@Deprecated
+	@Override
-	public default boolean add(CLASS_TYPE o) { return add(OBJ_TO_KEY(o)); }
+	@Deprecated
-	
+	public default boolean add(CLASS_TYPE o) { return add(OBJ_TO_KEY(o)); }
-	/** {@inheritDoc}
+	
-	 * <p>This default implementation delegates to the corresponding type-specific function.
+	/** {@inheritDoc}
-	 * @deprecated Please use the corresponding type-specific function instead. 
+	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 */
+	 * @deprecated Please use the corresponding type-specific function instead. 
-	@Override
+	 */
-	@Deprecated
+	@Override
-	public default boolean contains(Object o) { return o != null && contains(CLASS_TO_KEY(o)); }
+	@Deprecated
-	
+	public default boolean contains(Object o) { return o != null && contains(CLASS_TO_KEY(o)); }
-	/** {@inheritDoc}
+	
- 	 * <p>This default implementation delegates to the corresponding type-specific function.
+	/** {@inheritDoc}
- 	 * @deprecated Please use the corresponding type-specific function instead. 
+ 	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 */
+ 	 * @deprecated Please use the corresponding type-specific function instead. 
-	@Override
+ 	 */
-	@Deprecated
+	@Override
-	public default boolean remove(Object o) { return o != null && REMOVE_KEY(CLASS_TO_KEY(o)); }
+	@Deprecated
-	
+	public default boolean remove(Object o) { return o != null && REMOVE_KEY(CLASS_TO_KEY(o)); }
-#endif
+	
-	/**
+#endif
-	 * Returns a Type-Specific Iterator to reduce (un)boxing
+	/**
-	 * @return a iterator of the collection
+	 * Returns a Type-Specific Iterator to reduce (un)boxing
-	 * @see Collection#iterator()
+	 * @return a iterator of the collection
-	 */
+	 * @see Collection#iterator()
-	@Override
+	 */
-	public ITERATOR KEY_GENERIC_TYPE iterator();
+	@Override
-	
+	public ITERATOR KEY_GENERIC_TYPE iterator();
-	/**
+	
-	 * Creates a Wrapped Collection that is Synchronized
+	/**
-	 * @return a new Collection that is synchronized
+	 * Creates a Wrapped Collection that is Synchronized
-	 * @see COLLECTIONS#synchronize
+	 * @return a new Collection that is synchronized
-	 */
+	 * @see COLLECTIONS#synchronize
-	public default COLLECTION KEY_GENERIC_TYPE synchronize() { return COLLECTIONS.synchronize(this); }
+	 */
-	
+	public default COLLECTION KEY_GENERIC_TYPE synchronize() { return COLLECTIONS.synchronize(this); }
-	/**
+	
-	 * Creates a Wrapped Collection that is Synchronized
+	/**
-	 * @param mutex is the controller of the synchronization block
+	 * Creates a Wrapped Collection that is Synchronized
-	 * @return a new Collection Wrapper that is synchronized
+	 * @param mutex is the controller of the synchronization block
-	 * @see COLLECTIONS#synchronize
+	 * @return a new Collection Wrapper that is synchronized
-	 */
+	 * @see COLLECTIONS#synchronize
-	public default COLLECTION KEY_GENERIC_TYPE synchronize(Object mutex) { return COLLECTIONS.synchronize(this, mutex); }
+	 */
-	
+	public default COLLECTION KEY_GENERIC_TYPE synchronize(Object mutex) { return COLLECTIONS.synchronize(this, mutex); }
-	/**
+	
-	 * Creates a Wrapped Collection that is unmodifiable
+	/**
-	 * @return a new Collection Wrapper that is unmodifiable
+	 * Creates a Wrapped Collection that is unmodifiable
-	 * @see COLLECTIONS#unmodifiable
+	 * @return a new Collection Wrapper that is unmodifiable
-	 */
+	 * @see COLLECTIONS#unmodifiable
-	public default COLLECTION KEY_GENERIC_TYPE unmodifiable() { return COLLECTIONS.unmodifiable(this); }
+	 */
-	
+	public default COLLECTION KEY_GENERIC_TYPE unmodifiable() { return COLLECTIONS.unmodifiable(this); }
-#if SPLIT_ITERATOR_FEATURE
+	
-#if PRIMITIVES
+#if SPLIT_ITERATOR_FEATURE
-	/**
+#if PRIMITIVES
-	 * Returns a Java-Type-Specific Stream to reduce boxing/unboxing.
+	/**
-	 * @return a Stream of the closest java type
+	 * Returns a Java-Type-Specific Stream to reduce boxing/unboxing.
-	 */
+	 * @return a Stream of the closest java type
-	default JAVA_STREAM primitiveStream() { return StreamSupport.NEW_STREAM(SPLIT_ITERATORS.createJavaSplititerator(this, 0), false); }
+	 */
-	
+	default JAVA_STREAM primitiveStream() { return StreamSupport.NEW_STREAM(SPLIT_ITERATORS.createJavaSplititerator(this, 0), false); }
-	/**
+	
-	 * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing.
+	/**
-	 * @return a Stream of the closest java type
+	 * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing.
-	 */
+	 * @return a Stream of the closest java type
-	default JAVA_STREAM parallelPrimitiveStream() { return StreamSupport.NEW_STREAM(SPLIT_ITERATORS.createJavaSplititerator(this, 0), true); }
+	 */
-	
+	default JAVA_STREAM parallelPrimitiveStream() { return StreamSupport.NEW_STREAM(SPLIT_ITERATORS.createJavaSplititerator(this, 0), true); }
-#endif
+	
-#if STREAM_FEATURE
+#endif
-	/**
+#if STREAM_FEATURE
-	 * A Type Specific Type Splititerator to reduce boxing/unboxing
+	/**
-	 * @return type specific splititerator
+	 * 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); }
+	@Override
-#endif
+	default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
-#endif
+#endif
+#endif
 }

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

@@ -1,439 +1,490 @@
-package speiger.src.collections.PACKAGE.collections;
+package speiger.src.collections.PACKAGE.collections;
-
+
-import java.util.Objects;
+import java.util.Objects;
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-#if !TYPE_OBJECT
+#if JDK_FUNCTION
-
+import java.util.function.PREDICATE;
-import speiger.src.collections.PACKAGE.functions.CONSUMER;
+#endif
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
+
-import speiger.src.collections.objects.collections.ObjectIterable;
+#if !TYPE_OBJECT
-#else
+
-import java.util.function.BiFunction;
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
-import java.util.Comparator;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
-import speiger.src.collections.ints.functions.function.Int2ObjectFunction;
+import speiger.src.collections.objects.collections.ObjectIterable;
-
+#else
-#endif
+import java.util.function.BiFunction;
-import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
+import java.util.function.IntFunction;
-import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+import java.util.Comparator;
-import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+
-import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#if BOOLEAN_COLLECTION_MODULE
-#if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
+import speiger.src.collections.booleans.collections.BooleanIterable;
-import speiger.src.collections.PACKAGE.lists.LIST;
+#endif
-#if ARRAY_LIST_FEATURE
+#iterate
-import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+#argument OUTPUT_ITERABLE ByteIterable ShortIterable IntIterable LongIterable FloatIterable DoubleIterable
-#else
+#argument MAPPER ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction
-import speiger.src.collections.PACKAGE.lists.LINKED_LIST;
+#argument PACKAGE bytes shorts ints longs floats doubles
-#endif
+#argument FILTER_TYPE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE
-#endif
+#if FILTER_TYPE
-#if SET_MODULE && !TYPE_BOOLEAN
+import speiger.src.collections.objects.functions.function.MAPPER;
-#if LINKED_SET_FEATURE || LINKED_CUSTOM_SET_FEATURE || SET_FEATURE || CUSTOM_SET_FEATURE || RB_TREE_SET_FEATURE || AVL_TREE_SET_FEATURE || ARRAY_SET_FEATURE
+import speiger.src.collections.PACKAGE.collections.OUTPUT_ITERABLE;
-import speiger.src.collections.PACKAGE.sets.SET;
+#endif
-#if LINKED_SET_FEATURE
+#enditerate
-import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
+#endif
-#else if LINKED_CUSTOM_SET_FEATURE
+import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
-import speiger.src.collections.PACKAGE.sets.LINKED_CUSTOM_HASH_SET;
+import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#else if SET_FEATURE
+import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
-import speiger.src.collections.PACKAGE.sets.HASH_SET;
+#if !JDK_FUNCTION
-#else if CUSTOM_SET_FEATURE
+import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
-import speiger.src.collections.PACKAGE.sets.CUSTOM_HASH_SET;
+#endif
-#else if RB_TREE_SET_FEATURE
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
-import speiger.src.collections.PACKAGE.sets.RB_TREE_SET;
+#if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
-#else if AVL_TREE_SET_FEATURE
+import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.collections.PACKAGE.sets.AVL_TREE_SET;
+#if ARRAY_LIST_FEATURE
-#else if ARRAY_SET_FEATURE
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
-import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
+#else
-#endif
+import speiger.src.collections.PACKAGE.lists.LINKED_LIST;
-#endif
+#endif
-#endif
+#endif
-import speiger.src.collections.PACKAGE.utils.ARRAYS;
+#if SET_MODULE && !TYPE_BOOLEAN
-#if ASYNC_MODULE
+#if LINKED_SET_FEATURE || LINKED_CUSTOM_SET_FEATURE || SET_FEATURE || CUSTOM_SET_FEATURE || RB_TREE_SET_FEATURE || AVL_TREE_SET_FEATURE || ARRAY_SET_FEATURE
-import speiger.src.collections.PACKAGE.utils.ASYNC_BUILDER;
+import speiger.src.collections.PACKAGE.sets.SET;
-#endif
+#if LINKED_SET_FEATURE
-#if SPLIT_ITERATOR_FEATURE
+import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
-import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
+#else if LINKED_CUSTOM_SET_FEATURE
-#endif
+import speiger.src.collections.PACKAGE.sets.LINKED_CUSTOM_HASH_SET;
-import speiger.src.collections.PACKAGE.utils.ITERABLES;
+#else if SET_FEATURE
-import speiger.src.collections.PACKAGE.utils.ITERATORS;
+import speiger.src.collections.PACKAGE.sets.HASH_SET;
-#if !LINKED_HASH_SET_FEATURE && LINKED_CUSTOM_HASH_SET_FEATURE
+#else if CUSTOM_SET_FEATURE
-import speiger.src.collections.PACKAGE.utils.STRATEGY;
+import speiger.src.collections.PACKAGE.sets.CUSTOM_HASH_SET;
-#endif
+#else if RB_TREE_SET_FEATURE
-import speiger.src.collections.utils.ISizeProvider;
+import speiger.src.collections.PACKAGE.sets.RB_TREE_SET;
-
+#else if AVL_TREE_SET_FEATURE
-/**
+import speiger.src.collections.PACKAGE.sets.AVL_TREE_SET;
- * A Type-Specific {@link Iterable} that reduces (un)boxing
+#else if ARRAY_SET_FEATURE
- * @Type(T)
+import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
- */
+#endif
-public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
+#endif
-{
+#endif
-	/**
+import speiger.src.collections.PACKAGE.utils.ARRAYS;
-	 * Returns an iterator over elements of type {@code T}.
+#if ASYNC_MODULE
-	 *
+import speiger.src.collections.PACKAGE.utils.ASYNC_BUILDER;
-	 * @return an Iterator.
+#endif
-	 */
+#if SPLIT_ITERATOR_FEATURE
-	@Override
+import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
-	ITERATOR KEY_GENERIC_TYPE iterator();
+#endif
-	
+import speiger.src.collections.PACKAGE.utils.ITERABLES;
-#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.utils.ITERATORS;
-	/**
+#if !LINKED_HASH_SET_FEATURE && LINKED_CUSTOM_HASH_SET_FEATURE
-	 * A Type Specific foreach function that reduces (un)boxing
+import speiger.src.collections.PACKAGE.utils.STRATEGY;
-	 * 
+#endif
-	 * @implSpec
+import speiger.src.collections.utils.ISizeProvider;
-	 * <p>The default implementation behaves as if:
+
-	 * <pre>{@code
+/**
-	 *	iterator().forEachRemaining(action);
+ * A Type-Specific {@link Iterable} that reduces (un)boxing
-	 * }</pre>
+ * @Type(T)
-	 *
+ */
-	 * @param action The action to be performed for each element
+public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
-	 * @throws NullPointerException if the specified action is null
+{
-	 * @see Iterable#forEach(Consumer)
+	/**
-	 */
+	 * Returns an iterator over elements of type {@code T}.
-	default void forEach(CONSUMER action) {
+	 *
-		Objects.requireNonNull(action);
+	 * @return an Iterator.
-		iterator().forEachRemaining(action);
+	 */
-	}
+	@Override
-	
+	ITERATOR KEY_GENERIC_TYPE iterator();
-	/** {@inheritDoc}
+	
-	* <p>This default implementation delegates to the corresponding type-specific function.
+#if !TYPE_OBJECT
-	* @deprecated Please use the corresponding type-specific function instead. 
+	/**
-	*/
+	 * A Type Specific foreach function that reduces (un)boxing
-	@Deprecated
+	 * 
-	@Override
+	 * @implSpec
-	default void forEach(Consumer<? super CLASS_TYPE> action) {
+	 * <p>The default implementation behaves as if:
-		Objects.requireNonNull(action);
+	 * <pre>{@code
-		iterator().forEachRemaining(action);
+	 *	iterator().forEachRemaining(action);
-	}
+	 * }</pre>
-	
+	 *
-#endif
+	 * @param action The action to be performed for each element
-	/**
+	 * @throws NullPointerException if the specified action is null
-	 * Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
+	 * @see Iterable#forEach(Consumer)
-	 * @param input the object that should be included
+	 */
-	 * @param action The action to be performed for each element
+	default void forEach(CONSUMER action) {
-	 * @param <E> the generic type of the Object
+		Objects.requireNonNull(action);
-	 * @throws java.lang.NullPointerException if the specified action is null
+		iterator().forEachRemaining(action);
-	 */
+	}
-	default <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
+	
-		Objects.requireNonNull(action);
+	/** {@inheritDoc}
-		iterator().forEachRemaining(input, action);
+	* <p>This default implementation delegates to the corresponding type-specific function.
-	}
+	* @deprecated Please use the corresponding type-specific function instead. 
-	
+	*/
-#if SPLIT_ITERATOR_FEATURE
+	@Deprecated
-	/**
+	@Override
-	 * A Type Specific Type Splititerator to reduce boxing/unboxing
+	default void forEach(Consumer<? super CLASS_TYPE> action) {
-	 * @return type specific splititerator
+		Objects.requireNonNull(action);
-	 */
+		iterator().forEachRemaining(action);
-	@Override
+	}
-	default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createUnknownSplititerator(iterator(), 0); }
+	
-	
+#endif
-#endif
+	/**
-#if ASYNC_MODULE
+	 * A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
-	/**
+	 * @param action The action to be performed for each element
-	 * Creates a Async Builder for moving work of the thread.
+	 * @throws java.lang.NullPointerException if the specified action is null
-	 * It is not designed to split the work to multithreaded work, so using this keep it singlethreaded, but it allows to be moved to another thread.
+	 */
-	 * @see ASYNC_BUILDER
+	public default void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
-	 * @return a AsyncBuilder
+		Objects.requireNonNull(action);
-	 */
+		int index = 0;
-	default ASYNC_BUILDER KEY_GENERIC_TYPE asAsync() {
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();action.accept(index++, iter.NEXT()));
-		return new ASYNC_BUILDERBRACES(this);
+	}
-	}
+	
-
+	/**
-#endif
+	 * Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
-	/**
+	 * @param input the object that should be included
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
+	 * @param action The action to be performed for each element
-	 * @param mapper the mapping function
+	 * @param <E> the generic type of the Object
-	 * @param <E> The return type.
+	 * @throws java.lang.NullPointerException if the specified action is null
-	 * @return a new Iterable that returns the desired result
+	 */
-	 */
+	default <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
-	default <E> ObjectIterable<E> map(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E> mapper) {
+		Objects.requireNonNull(action);
-		return ITERABLES.map(this, mapper);
+		iterator().forEachRemaining(input, action);
-	}
+	}
-	
+	
-	/**
+#if SPLIT_ITERATOR_FEATURE
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
+	/**
-	 * @param mapper the flatMapping function
+	 * A Type Specific Type Splititerator to reduce boxing/unboxing
-	 * @param <V> The return type supplier.
+	 * @return type specific splititerator
-	 * @param <E> The return type.
+	 */
-	 * @return a new Iterable that returns the desired result
+	@Override
-	 * @note does not support TO_ARRAY optimizations.
+	default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createUnknownSplititerator(iterator(), 0); }
-	 */
+	
-	default <E, V extends Iterable<E>> ObjectIterable<E> flatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<V> mapper) {
+#endif
-		return ITERABLES.flatMap(this, mapper);
+#if ASYNC_MODULE
-	}
+	/**
-	
+	 * Creates a Async Builder for moving work of the thread.
-	/**
+	 * It is not designed to split the work to multithreaded work, so using this keep it singlethreaded, but it allows to be moved to another thread.
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
+	 * @see ASYNC_BUILDER
-	 * @param mapper the flatMapping function
+	 * @return a AsyncBuilder
-	 * @param <E> The return type.
+	 */
-	 * @return a new Iterable that returns the desired result
+	default ASYNC_BUILDER KEY_GENERIC_TYPE asAsync() {
-	 * @note does not support TO_ARRAY optimizations.
+		return new ASYNC_BUILDERBRACES(this);
-	 */
+	}
-	default <E> ObjectIterable<E> arrayflatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E[]> mapper) {
+
-		return ITERABLES.arrayFlatMap(this, mapper);
+#endif
-	}
+	/**
-	
+	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	/**
+	 * @param mapper the mapping function
-	 * A Helper function to reduce the usage of Streams and allows to filter out unwanted elements
+	 * @param <E> The return type.
-	 * @param filter the elements that should be kept.
+	 * @return a new Iterable that returns the desired result
-	 * @return a Iterable that filtered out all unwanted elements
+	 */
-	 * @note does not support TO_ARRAY optimizations.
+	default <E> ObjectIterable<E> map(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E> mapper) {
-	 */
+		return ITERABLES.map(this, mapper);
-	default ITERABLE KEY_GENERIC_TYPE filter(PREDICATE KEY_GENERIC_TYPE filter) {
+	}
-		return ITERABLES.filter(this, filter);
+	
-	}
+#if TYPE_OBJECT
-	
+#iterate
-	/**
+#argument OUTPUT_ITERABLE BooleanIterable ByteIterable ShortIterable IntIterable LongIterable FloatIterable DoubleIterable
-	 * A Helper function to reduce the usage of Streams and allows to filter out duplicated elements
+#argument MAPPER Predicate ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction
-	 * @return a Iterable that filtered out all duplicated elements
+#argument DATA_TYPE Boolean Byte Short Int Long Float Double
-	 * @note does not support TO_ARRAY optimizations.
+#argument FILTER_TYPE BOOLEAN_COLLECTION_MODULE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE
-	 */
+#if FILTER_TYPE
-	default ITERABLE KEY_GENERIC_TYPE distinct() {
+	/**
-		return ITERABLES.distinct(this);
+	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	}
+	 * @param mapper the mapping function
-	
+	 * @return a new Iterable that returns the desired result
-	/**
+	 */
-	 * A Helper function to reduce the usage of Streams and allows to repeat elements a desired amount of times
+	default OUTPUT_ITERABLE mapToDATA_TYPE(MAPPER<T> mapper) {
-	 * @param repeats how many times the elements should be repeated
+		return ITERABLES.mapToDATA_TYPE(this, mapper);
-	 * @return a Iterable that is repeating multiple times
+	}
-	 */
+	
-	default ITERABLE KEY_GENERIC_TYPE repeat(int repeats) {
+#endif
-		return ITERABLES.repeat(this, repeats);
+#enditerate
-	}
+#endif
-	
+	/**
-	/**
+	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	 * A Helper function to reduce the usage of Streams and allows to limit the amount of elements
+	 * @param mapper the flatMapping function
-	 * @param limit the amount of elements it should be limited to
+	 * @param <V> The return type supplier.
-	 * @return a Iterable that is limited in length
+	 * @param <E> The return type.
-	 */
+	 * @return a new Iterable that returns the desired result
-	default ITERABLE KEY_GENERIC_TYPE limit(long limit) {
+	 * @note does not support TO_ARRAY optimizations.
-		return ITERABLES.limit(this, limit);
+	 */
-	}
+	default <E, V extends Iterable<E>> ObjectIterable<E> flatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<V> mapper) {
-	
+		return ITERABLES.flatMap(this, mapper);
-	/**
+	}
-	 * A Helper function to reduce the usage of Streams and allows to sort the elements
+	
-	 * @param sorter that sorts the elements.
+	/**
-	 * @return a Iterable that is sorted
+	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	 */
+	 * @param mapper the flatMapping function
-	default ITERABLE KEY_GENERIC_TYPE sorted(COMPARATOR KEY_GENERIC_TYPE sorter) {
+	 * @param <E> The return type.
-		return ITERABLES.sorted(this, sorter);
+	 * @return a new Iterable that returns the desired result
-	}
+	 * @note does not support TO_ARRAY optimizations.
-	
+	 */
-	/**
+	default <E> ObjectIterable<E> arrayflatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E[]> mapper) {
-	 * A Helper function to reduce the usage of Streams and allows to preview elements before they are iterated through
+		return ITERABLES.arrayFlatMap(this, mapper);
-	 * @param action the action that should be applied
+	}
-	 * @return a Peeked Iterable
+	
-	 */
+	/**
-	default ITERABLE KEY_GENERIC_TYPE peek(CONSUMER KEY_GENERIC_TYPE action) {
+	 * A Helper function to reduce the usage of Streams and allows to filter out unwanted elements
-		return ITERABLES.peek(this, action);
+	 * @param filter the elements that should be kept.
-	}
+	 * @return a Iterable that filtered out all unwanted elements
-	
+	 * @note does not support TO_ARRAY optimizations.
-	/**
+	 */
-	 * A Helper function to reduce the usage of Streams and allows to collect all elements
+	default ITERABLE KEY_GENERIC_TYPE filter(PREDICATE KEY_GENERIC_TYPE filter) {
-	 * @param collection that the elements should be inserted to
+		return ITERABLES.filter(this, filter);
-	 * @param <E> the collection type
+	}
-	 * @return the input with the desired elements
+	
-	 */
+	/**
-	default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
+	 * A Helper function to reduce the usage of Streams and allows to filter out duplicated elements
-		ITERATORS.pour(iterator(), collection);
+	 * @return a Iterable that filtered out all duplicated elements
-		return collection;
+	 * @note does not support TO_ARRAY optimizations.
-	}
+	 */
-	
+	default ITERABLE KEY_GENERIC_TYPE distinct() {
-#if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
+		return ITERABLES.distinct(this);
-	/**
+	}
-	 * A Helper function that reduces the usage of streams and allows to collect all elements as a ArrayList
+	
-	 * @return a new ArrayList of all elements
+	/**
-	 */
+	 * A Helper function to reduce the usage of Streams and allows to repeat elements a desired amount of times
-	default LIST KEY_GENERIC_TYPE pourAsList() {
+	 * @param repeats how many times the elements should be repeated
-#if ARRAY_LIST_FEATURE
+	 * @return a Iterable that is repeating multiple times
-		return pour(new ARRAY_LISTBRACES());
+	 */
-#else
+	default ITERABLE KEY_GENERIC_TYPE repeat(int repeats) {
-		return pour(new LINKED_LISTBRACES());
+		return ITERABLES.repeat(this, repeats);
-#endif
+	}
-	}
+	
-	
+	/**
-#endif
+	 * A Helper function to reduce the usage of Streams and allows to limit the amount of elements
-#if !TYPE_BOOLEAN && SET_MODULE
+	 * @param limit the amount of elements it should be limited to
-#if LINKED_SET_FEATURE || LINKED_CUSTOM_SET_FEATURE || SET_FEATURE || CUSTOM_SET_FEATURE || RB_TREE_SET_FEATURE || AVL_TREE_SET_FEATURE || ARRAY_SET_FEATURE
+	 * @return a Iterable that is limited in length
-	/**
+	 */
-	 * A Helper function that reduces the usage of streams and allows to collect all elements as a LinkedHashSet
+	default ITERABLE KEY_GENERIC_TYPE limit(long limit) {
-	 * @return a new LinkedHashSet of all elements
+		return ITERABLES.limit(this, limit);
-	 */
+	}
-	default SET KEY_GENERIC_TYPE pourAsSet() { 
+	
-#if LINKED_SET_FEATURE
+	/**
-		return pour(new LINKED_HASH_SETBRACES());
+	 * A Helper function to reduce the usage of Streams and allows to sort the elements
-#else if LINKED_CUSTOM_SET_FEATURE
+	 * @param sorter that sorts the elements.
-		return pour(new LINKED_CUSTOM_HASH_SETBRACES(STRATEGY.normalStrategy()));
+	 * @return a Iterable that is sorted
-#else if SET_FEATURE
+	 */
-		return pour(new HASH_SETBRACES());
+	default ITERABLE KEY_GENERIC_TYPE sorted(COMPARATOR KEY_GENERIC_TYPE sorter) {
-#else if CUSTOM_SET_FEATURE
+		return ITERABLES.sorted(this, sorter);
-		return pour(new CUSTOM_HASH_SETBRACES(STRATEGY.normalStrategy()));
+	}
-#else if RB_TREE_SET_FEATURE
+	
-		return pour(new RB_Tree_SETBRACES());
+	/**
-#else if AVL_TREE_SET_FEATURE
+	 * A Helper function to reduce the usage of Streams and allows to preview elements before they are iterated through
-		return pour(new AVL_Tree_SETBRACES());
+	 * @param action the action that should be applied
-#else if ARRAY_SET_FEATURE
+	 * @return a Peeked Iterable
-		return pour(new ARRAY_SETBRACES());
+	 */
-#endif
+	default ITERABLE KEY_GENERIC_TYPE peek(CONSUMER KEY_GENERIC_TYPE action) {
-	}
+		return ITERABLES.peek(this, action);
-	
+	}
-#endif
+	
-#endif	
+	/**
-#if TYPE_OBJECT
+	 * A Helper function to reduce the usage of Streams and allows to collect all elements
-	/**
+	 * @param collection that the elements should be inserted to
-	 * A Helper function that reduces the usage of streams and allows to collect all elements as a Array
+	 * @param <E> the collection type
-	 * @param action is the creator function of said Array to ensure type is kept.
+	 * @return the input with the desired elements
-	 * @return a new Array of all elements
+	 */
-	 */
+	default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
-	default KEY_TYPE[] TO_ARRAY(Int2ObjectFunction<KEY_TYPE[]> action) {
+		ITERATORS.pour(iterator(), collection);
-		ISizeProvider prov = ISizeProvider.of(this);
+		return collection;
-		if(prov != null) {
+	}
-			int size = prov.size();
+	
-			if(size >= 0) {
+#if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
-				KEY_TYPE[] array = action.apply(size);
+	/**
-				ITERATORS.unwrap(array, iterator());
+	 * A Helper function that reduces the usage of streams and allows to collect all elements as a ArrayList
-				return array;
+	 * @return a new ArrayList of all elements
-			}
+	 */
-		}
+	default LIST KEY_GENERIC_TYPE pourAsList() {
-		return ARRAYS.pour(iterator(), action);
+#if ARRAY_LIST_FEATURE
-	}
+		return pour(new ARRAY_LISTBRACES());
-#else
+#else
-	/**
+		return pour(new LINKED_LISTBRACES());
-	 * A Helper function that reduces the usage of streams and allows to collect all elements as a Array
+#endif
-	 * @return a new Array of all elements
+	}
-	 */
+	
-	default KEY_TYPE[] TO_ARRAY() {
+#endif
-		ISizeProvider prov = ISizeProvider.of(this);
+#if !TYPE_BOOLEAN && SET_MODULE
-		if(prov != null) {
+#if LINKED_SET_FEATURE || LINKED_CUSTOM_SET_FEATURE || SET_FEATURE || CUSTOM_SET_FEATURE || RB_TREE_SET_FEATURE || AVL_TREE_SET_FEATURE || ARRAY_SET_FEATURE
-			int size = prov.size();
+	/**
-			if(size >= 0) {
+	 * A Helper function that reduces the usage of streams and allows to collect all elements as a LinkedHashSet
-				KEY_TYPE[] array = NEW_KEY_ARRAY(size);
+	 * @return a new LinkedHashSet of all elements
-				ITERATORS.unwrap(array, iterator());
+	 */
-				return array;
+	default SET KEY_GENERIC_TYPE pourAsSet() { 
-			}
+#if LINKED_SET_FEATURE
-		}
+		return pour(new LINKED_HASH_SETBRACES());
-		return ARRAYS.pour(iterator());
+#else if LINKED_CUSTOM_SET_FEATURE
-	}
+		return pour(new LINKED_CUSTOM_HASH_SETBRACES(STRATEGY.normalStrategy()));
-	
+#else if SET_FEATURE
-#endif
+		return pour(new HASH_SETBRACES());
-	/**
+#else if CUSTOM_SET_FEATURE
-	 * Helper function to reduce stream usage that allows to filter for any matches.
+		return pour(new CUSTOM_HASH_SETBRACES(STRATEGY.normalStrategy()));
-	 * @param filter that should be applied
+#else if RB_TREE_SET_FEATURE
-	 * @return true if any matches were found
+		return pour(new RB_Tree_SETBRACES());
-	 */
+#else if AVL_TREE_SET_FEATURE
-	default boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
+		return pour(new AVL_Tree_SETBRACES());
-		Objects.requireNonNull(filter);
+#else if ARRAY_SET_FEATURE
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+		return pour(new ARRAY_SETBRACES());
-			if(filter.test(iter.NEXT())) return true;
+#endif
-		}
+	}
-		return false;
+	
-	}
+#endif
-	
+#endif	
-	/**
+#if TYPE_OBJECT
-	 * Helper function to reduce stream usage that allows to filter for no matches.
+	/**
-	 * @param filter that should be applied
+	 * A Helper function that reduces the usage of streams and allows to collect all elements as a Array
-	 * @return true if no matches were found
+	 * @param action is the creator function of said Array to ensure type is kept.
-	 */
+	 * @param <E> the returning arrayType
-	default boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
+	 * @return a new Array of all elements
-		Objects.requireNonNull(filter);
+	 */
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+	default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
-			if(filter.test(iter.NEXT())) return false;
+		ISizeProvider prov = ISizeProvider.of(this);
-		}
+		if(prov != null) {
-		return true;
+			int size = prov.size();
-	}
+			if(size >= 0) {
-	
+				E[] array = action.apply(size);
-	/**
+				ITERATORS.unwrap(array, iterator());
-	 * Helper function to reduce stream usage that allows to filter for all matches.
+				return array;
-	 * @param filter that should be applied
+			}
-	 * @return true if all matches.
+		}
-	 */
+		return ARRAYS.pour(iterator(), action);
-	default boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
+	}
-		Objects.requireNonNull(filter);
+#else
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+	/**
-			if(!filter.test(iter.NEXT())) return false;
+	 * A Helper function that reduces the usage of streams and allows to collect all elements as a Array
-		}
+	 * @return a new Array of all elements
-		return true;
+	 */
-	}
+	default KEY_TYPE[] TO_ARRAY() {
-	
+		ISizeProvider prov = ISizeProvider.of(this);
-	/**
+		if(prov != null) {
-	 * Helper function to reduce stream usage that allows to filter for the first match.
+			int size = prov.size();
-	 * @param filter that should be applied
+			if(size >= 0) {
-	 * @return the found value or the null equivalent variant.
+				KEY_TYPE[] array = NEW_KEY_ARRAY(size);
-	 */
+				ITERATORS.unwrap(array, iterator());
-	default KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+				return array;
-		Objects.requireNonNull(filter);
+			}
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+		}
-			KEY_TYPE entry = iter.NEXT();
+		return ARRAYS.pour(iterator());
-			if(filter.test(entry)) return entry;
+	}
-		}
+	
-		return EMPTY_VALUE;
+#endif
-	}
+	/**
-	
+	 * Helper function to reduce stream usage that allows to filter for any matches.
-#if !TYPE_OBJECT
+	 * @param filter that should be applied
-	/**
+	 * @return true if any matches were found
-	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
+	 */
-     * elements of this Iterable
+	default boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
-	 * @param operator the operation that should be applied
+		Objects.requireNonNull(filter);
-	 * @param identity the start value
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-	 * @return the reduction result, returns identity if nothing was found
+			if(filter.test(iter.NEXT())) return true;
-	 */
+		}
-	default KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		return false;
-		Objects.requireNonNull(operator);
+	}
-		KEY_TYPE state = identity;
+	
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+	/**
-			state = operator.APPLY_VALUE(state, iter.NEXT());
+	 * Helper function to reduce stream usage that allows to filter for no matches.
-		}
+	 * @param filter that should be applied
-		return state;
+	 * @return true if no matches were found
-	}
+	 */
-	
+	default boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
-#else
+		Objects.requireNonNull(filter);
-	/**
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
+			if(filter.test(iter.NEXT())) return false;
-     * elements of this Iterable
+		}
-	 * @param operator the operation that should be applied
+		return true;
-	 * @param identity the start value
+	}
-	 * @Type(E)
+	
-	 * @return the reduction result, returns identity if nothing was found
+	/**
-	 */
+	 * Helper function to reduce stream usage that allows to filter for all matches.
-	default <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+	 * @param filter that should be applied
-		Objects.requireNonNull(operator);
+	 * @return true if all matches.
-		KEY_SPECIAL_TYPE state = identity;
+	 */
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+	default boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
-			state = operator.APPLY_VALUE(state, iter.NEXT());
+		Objects.requireNonNull(filter);
-		}
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-		return state;
+			if(!filter.test(iter.NEXT())) return false;
-	}
+		}
-	
+		return true;
-#endif
+	}
-	/**
+	
-	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
+	/**
-	 * elements of this Iterable
+	 * Helper function to reduce stream usage that allows to filter for the first match.
-	 * @param operator the operation that should be applied
+	 * @param filter that should be applied
-	 * @return the reduction result, returns null value if nothing was found
+	 * @return the found value or the null equivalent variant.
-	 */
+	 */
-	default KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	default KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
-		Objects.requireNonNull(operator);
+		Objects.requireNonNull(filter);
-		KEY_TYPE state = EMPTY_VALUE;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-		boolean empty = true;
+			KEY_TYPE entry = iter.NEXT();
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			if(filter.test(entry)) return entry;
-			if(empty) {
+		}
-				empty = false;
+		return EMPTY_VALUE;
-				state = iter.NEXT();
+	}
-				continue;
+	
-			}
+#if !TYPE_OBJECT
-			state = operator.APPLY_VALUE(state, iter.NEXT());
+	/**
-		}
+	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
-		return state;
+     * elements of this Iterable
-	}	
+	 * @param operator the operation that should be applied
-	
+	 * @param identity the start value
-	/**
+	 * @return the reduction result, returns identity if nothing was found
-	 * Helper function to reduce stream usage that allows to count the valid elements.
+	 */
-	 * @param filter that should be applied
+	default KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-	 * @return the amount of Valid Elements
+		Objects.requireNonNull(operator);
-	 */
+		KEY_TYPE state = identity;
-	default int count(PREDICATE KEY_GENERIC_TYPE filter) {
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
-		Objects.requireNonNull(filter);
+			state = operator.APPLY_VALUE(state, iter.NEXT());
-		int result = 0;
+		}
-		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+		return state;
-			if(filter.test(iter.NEXT())) result++;
+	}
-		}
+	
-		return result;
+#else
-	}
+	/**
+	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
+     * elements of this Iterable
+	 * @param operator the operation that should be applied
+	 * @param identity the start value
+	 * @Type(E)
+	 * @return the reduction result, returns identity if nothing was found
+	 */
+	default <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			state = operator.APPLY_VALUE(state, iter.NEXT());
+		}
+		return state;
+	}
+	
+#endif
+	/**
+	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
+	 * elements of this Iterable
+	 * @param operator the operation that should be applied
+	 * @return the reduction result, returns null value if nothing was found
+	 */
+	default KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			if(empty) {
+				empty = false;
+				state = iter.NEXT();
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, iter.NEXT());
+		}
+		return state;
+	}	
+	
+	/**
+	 * Helper function to reduce stream usage that allows to count the valid elements.
+	 * @param filter that should be applied
+	 * @return the amount of Valid Elements
+	 */
+	default int count(PREDICATE KEY_GENERIC_TYPE filter) {
+		Objects.requireNonNull(filter);
+		int result = 0;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			if(filter.test(iter.NEXT())) result++;
+		}
+		return result;
+	}
 }

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

@@ -1,5 +1,7 @@
 package speiger.src.collections.PACKAGE.collections;
 
+import java.util.NoSuchElementException;
+
 import speiger.src.collections.utils.Stack;
 
 /**
@@ -14,6 +16,14 @@ public interface STACK
 	 */
 	public void push(KEY_TYPE e);
 	
+	/**
+	 * Helper function that pushes the top element on top of the stack again.
+	 * @throws NoSuchElementException if the stack is empty
+	 */
+	public default void pushTop() {
+		push(top());
+	}
+	
 	/**
 	 * Removes the Object on top of the stack.
 	 * @return the element that is on top of the stack
@@ -59,4 +69,19 @@ public interface STACK
 	public default boolean isEmpty() {
 		return size() == 0;
 	}
+	
+	/**
+	 * A method to drop the contents of the Stack without clearing the stack
+	 * @Type(E)
+	 * @return the contents of the stack into a seperate array.
+	 */
+	public default GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY() { return TO_ARRAY(NEW_SPECIAL_KEY_ARRAY(size())); }
+	/**
+	 * A method to drop the contents of the Stack without clearing the stack
+	 * @param input where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
+	 * @Type(E)
+	 * @return the contents of the stack into a seperate array.
+	 * @note if the Type is generic then a Object Array is created instead of a Type Array
+	 */
+	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input);
 }

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

@@ -1,70 +1,70 @@
-package speiger.src.collections.PACKAGE.functions;
+package speiger.src.collections.PACKAGE.functions;
-
+
-import java.util.Comparator;
+import java.util.Comparator;
-import java.util.Objects;
+import java.util.Objects;
-
+
-/**
+/**
- * Type-Specific Class for Comparator to reduce (un)boxing
+ * Type-Specific Class for Comparator to reduce (un)boxing
- */
+ */
-public interface COMPARATOR extends Comparator<CLASS_TYPE> 
+public interface COMPARATOR extends Comparator<CLASS_TYPE> 
-{
+{
-	/**
+	/**
-	 * Type-Specific compare function to reduce (un)boxing
+	 * Type-Specific compare function to reduce (un)boxing
-	 * @param o1 the first object to be compared.
+	 * @param o1 the first object to be compared.
-	 * @param o2 the second object to be compared.
+	 * @param o2 the second object to be compared.
-	 * @return a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
+	 * @return a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
-	 * @see Comparator#compare(Object, Object)
+	 * @see Comparator#compare(Object, Object)
-	 */
+	 */
-	int compare(KEY_TYPE o1, KEY_TYPE o2);
+	int compare(KEY_TYPE o1, KEY_TYPE o2);
-	
+	
-	/** {@inheritDoc}
+	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
+	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
+	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
+	 */
-	@Override
+	@Override
-	@Deprecated
+	@Deprecated
-	default int compare(CLASS_TYPE o1, CLASS_TYPE o2) {
+	default int compare(CLASS_TYPE o1, CLASS_TYPE o2) {
-		return compare(OBJ_TO_KEY(o1), OBJ_TO_KEY(o2));
+		return compare(OBJ_TO_KEY(o1), OBJ_TO_KEY(o2));
-	}
+	}
-	
+	
-	/**
+	/**
-	 * A Wrapper function to convert a Non-Type-Specific Comparator to a Type-Specific-Comparator
+	 * A Wrapper function to convert a Non-Type-Specific Comparator to a Type-Specific-Comparator
-	 * @param c comparator to convert
+	 * @param c comparator to convert
-	 * @return the wrapper of the comparator
+	 * @return the wrapper of the comparator
-	 * @throws NullPointerException if the comparator is null
+	 * @throws NullPointerException if the comparator is null
-	 */
+	 */
-	public static COMPARATOR of(Comparator<CLASS_TYPE> c) {
+	public static COMPARATOR of(Comparator<CLASS_TYPE> c) {
-		Objects.requireNonNull(c);
+		Objects.requireNonNull(c);
-		return (K, V) -> c.compare(KEY_TO_OBJ(K), KEY_TO_OBJ(V));
+		return (K, V) -> c.compare(KEY_TO_OBJ(K), KEY_TO_OBJ(V));
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public default COMPARATOR reversed() {
+	public default COMPARATOR reversed() {
-		return new Reversed(this);
+		return new Reversed(this);
-	}
+	}
-	
+	
-	/**
+	/**
-	 * A Type Specific Reversed Comparator to reduce boxing/unboxing
+	 * A Type Specific Reversed Comparator to reduce boxing/unboxing
-	 */
+	 */
-	static class Reversed implements COMPARATOR
+	static class Reversed implements COMPARATOR
-	{
+	{
-		COMPARATOR original;
+		COMPARATOR original;
-		
+		
-		/**
+		/**
-		 * default constructor
+		 * default constructor
-		 * @param original that is going to be reversed
+		 * @param original that is going to be reversed
-		 */
+		 */
-		public Reversed(COMPARATOR original) {
+		public Reversed(COMPARATOR original) {
-			this.original = original;
+			this.original = original;
-		}
+		}
-		
+		
-		public int compare(KEY_TYPE o1, KEY_TYPE o2) {
+		public int compare(KEY_TYPE o1, KEY_TYPE o2) {
-			return original.compare(o2, o1);
+			return original.compare(o2, o1);
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public COMPARATOR reversed() {
+		public COMPARATOR reversed() {
-			return original;
+			return original;
-		}
+		}
-	}
+	}
 }

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

@@ -1,26 +1,19 @@
-package speiger.src.collections.PACKAGE.functions;
+package speiger.src.collections.PACKAGE.functions;
-
+
-/**
+/**
- * Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
+ * Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
- * @Type(T)
+ * @Type(T)
- */
+ */
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-public interface SUPPLIER KEY_GENERIC_TYPE extends java.util.function.Supplier<KEY_TYPE>
+public interface SUPPLIER KEY_GENERIC_TYPE extends java.util.function.Supplier<KEY_TYPE>
-#else if JDK_TYPE && !TYPE_BOOLEAN
+#else if JDK_TYPE && !TYPE_BOOLEAN
-public interface SUPPLIER KEY_GENERIC_TYPE extends JAVA_SUPPLIER
+public interface SUPPLIER KEY_GENERIC_TYPE extends JAVA_SUPPLIER
-#else
+#else
-public interface SUPPLIER KEY_GENERIC_TYPE
+public interface SUPPLIER KEY_GENERIC_TYPE
-#endif
+#endif
-{
+{
-	/**
+	/**
-	 * @return the supplied value
+	 * @return the supplied value
-	 */
+	 */
-	public KEY_TYPE GET_KEY();
+	public KEY_TYPE SUPPLY_GET();
-#if JDK_TYPE && PRIMITIVES
-	
-	@Override
-	public default KEY_TYPE GET_JAVA() {
-		return GET_KEY();
-	}
-#endif
 }

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

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

src/builder/resources/speiger/assets/collections/templates/functions/function/Function.template

@@ -1,67 +1,134 @@
-package speiger.src.collections.PACKAGE.functions.function;
+package speiger.src.collections.PACKAGE.functions.function;
-
+
-#if JDK_FUNCTION && VALUE_BOOLEAN
+#if VALUE_BOOLEAN || SAME_TYPE
-import java.util.Objects;
+import java.util.Objects;
-#endif
+#endif
-
+
-/**
+/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
+ * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- * @Type(T)
+ * @Type(T)
- * @ValueType(V)
+ * @ValueType(V)
- */
+ */
-@FunctionalInterface
+@FunctionalInterface
-#if JDK_FUNCTION
+#if JDK_FUNCTION
-public interface FUNCTION KEY_VALUE_GENERIC_TYPE extends JAVA_FUNCTION KEY_VALUE_GENERIC_TYPE
+public interface FUNCTION KEY_VALUE_GENERIC_TYPE extends JAVA_FUNCTION KEY_VALUE_GENERIC_TYPE
-#else
+#else
-public interface FUNCTION KEY_VALUE_GENERIC_TYPE
+public interface FUNCTION KEY_VALUE_GENERIC_TYPE
-#endif
+#endif
-{
+{
-	/**
+	/**
-	 * Type Specific get function to reduce boxing/unboxing
+	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
+	 * @param k the value that should be processed
-	 * @return the result of the function
+	 * @return the result of the function
-	 */
+	 */
-	public VALUE_TYPE APPLY(KEY_TYPE k);
+	public VALUE_TYPE APPLY(KEY_TYPE k);
-	
+	
-#if JDK_FUNCTION && VALUE_BOOLEAN
+#if SAME_TYPE
-	
+	/**
-	/**
+	 * Creates a Default function that returns the input provided.
-	 * A Type specific and-function helper function that reduces boxing/unboxing
+	 * @Type(T)
-	 * @param other the other function that should be merged with.
+	 * @return a input returning function
-	 * @return a function that compares values in a and comparason
+	 */
-	 */
+	public static GENERIC_KEY_BRACES FUNCTION KEY_SAME_GENERIC_TYPE identity() {
-	public default FUNCTION KEY_VALUE_GENERIC_TYPE andType(FUNCTION KEY_VALUE_GENERIC_TYPE other) {
+		return T -> T;
-		Objects.requireNonNull(other);
+	}
-		return T -> APPLY(T) && other.APPLY(T);
+	
-	}
+	/**
-	
+	 * Returns a composed function that first applies the {@code before}
-	@Override
+     * function to its input, and then applies this function to the result.
-	@Deprecated
+     * If evaluation of either function throws an exception, it is relayed to
-	public default FUNCTION KEY_VALUE_GENERIC_TYPE and(JAVA_FUNCTION KEY_VALUE_SUPER_GENERIC_TYPE other) {
+     * the caller of the composed function.
-		Objects.requireNonNull(other);
+     * 
-		return T -> APPLY(T) && other.APPLY(T);
+     * @Type(I)
-	}
+     * @param before the function that should be used first
-	
+     * @return a composed function with a different starting function.
-	@Override
+	 */
-	public default FUNCTION KEY_VALUE_GENERIC_TYPE negate() {
+	public default GENERIC_SPECIAL_VALUE_BRACES<I> FUNCTION SV_GENERIC_TYPE<I> compose(FUNCTION SK_GENERIC_TYPE<I> before) {
-		return T -> !APPLY(T);
+        Objects.requireNonNull(before);
-	}
+		return T -> APPLY(before.APPLY(T));
-	
+	}
-	/**
+	
-	 * A Type specific or-function helper function that reduces boxing/unboxing
+	/**
-	 * @param other the other function that should be merged with.
+     * Returns a composed function that first applies this function to
-	 * @return a function that compares values in a or comparason
+     * its input, and then applies the {@code after} function to the result.
-	 */
+     * If evaluation of either function throws an exception, it is relayed to
-	public default FUNCTION KEY_VALUE_GENERIC_TYPE orType(FUNCTION KEY_VALUE_GENERIC_TYPE other) {
+     * the caller of the composed function.
-		Objects.requireNonNull(other);
+     * 
-		return T -> APPLY(T) || other.APPLY(T);
+     * @Type(I)
-	}
+     * @param after the function that should be used last
-	
+     * @return a composed function with a different starting function.
-	@Override
+	 */
-	@Deprecated
+	public default GENERIC_SPECIAL_VALUE_BRACES<I> FUNCTION KS_GENERIC_TYPE<I> andThen(FUNCTION VS_GENERIC_TYPE<I> after) {
-	public default FUNCTION KEY_VALUE_GENERIC_TYPE or(JAVA_FUNCTION KEY_VALUE_SUPER_GENERIC_TYPE other) {
+        Objects.requireNonNull(after);
-		Objects.requireNonNull(other);
+		return T -> after.APPLY(APPLY(T));
-		return T -> APPLY(T) || other.APPLY(T);
+	}
-	}
+	
-#endif
+#endif
+#if VALUE_BOOLEAN
+	/**
+	 * Creates a Always true function that may be useful if you don't need to process information or just want a default.
+	 * @Type(T)
+	 * @return a default returning function
+	 */
+	public static GENERIC_KEY_BRACES FUNCTION KEY_GENERIC_TYPE alwaysTrue() {
+		return T -> true;
+	}
+	
+	/**
+	 * Creates a Always false function that may be useful if you don't need to process information or just want a default.
+	 * @Type(T)
+	 * @return a default returning function
+	 */
+	public static GENERIC_KEY_BRACES FUNCTION KEY_GENERIC_TYPE alwaysFalse() {
+		return T -> false;
+	}
+	
+	/**
+	 * A Type specific and-function helper function that reduces boxing/unboxing
+	 * @param other the other function that should be merged with.
+	 * @return a function that compares values in a and comparason
+	 */
+	public default FUNCTION KEY_VALUE_GENERIC_TYPE andType(FUNCTION KEY_VALUE_GENERIC_TYPE other) {
+		Objects.requireNonNull(other);
+		return T -> APPLY(T) && other.APPLY(T);
+	}
+	
+#if JDK_FUNCTION
+	@Override
+	@Deprecated
+	public default FUNCTION KEY_VALUE_GENERIC_TYPE and(JAVA_FUNCTION KEY_VALUE_SUPER_GENERIC_TYPE other) {
+		Objects.requireNonNull(other);
+		return T -> APPLY(T) && other.APPLY(T);
+	}
+	
+	@Override
+#else
+	/**
+	 * A type specific inverter function
+	 * @return the same function but inverts the result
+	 */
+#endif
+	public default FUNCTION KEY_VALUE_GENERIC_TYPE negate() {
+		return T -> !APPLY(T);
+	}
+	
+	/**
+	 * A Type specific or-function helper function that reduces boxing/unboxing
+	 * @param other the other function that should be merged with.
+	 * @return a function that compares values in a or comparason
+	 */
+	public default FUNCTION KEY_VALUE_GENERIC_TYPE orType(FUNCTION KEY_VALUE_GENERIC_TYPE other) {
+		Objects.requireNonNull(other);
+		return T -> APPLY(T) || other.APPLY(T);
+	}
+	
+#if JDK_FUNCTION
+	@Override
+	@Deprecated
+	public default FUNCTION KEY_VALUE_GENERIC_TYPE or(JAVA_FUNCTION KEY_VALUE_SUPER_GENERIC_TYPE other) {
+		Objects.requireNonNull(other);
+		return T -> APPLY(T) || other.APPLY(T);
+	}
+#endif
+#endif
 }

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

@@ -1,15 +1,20 @@
 package speiger.src.collections.PACKAGE.lists;
 
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.RandomAccess;
 
 import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
+#if INT_LIST_MODULE && !TYPE_INT
+import speiger.src.collections.ints.lists.IntList;
+#endif
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 import speiger.src.collections.utils.SanityChecks;
 
@@ -66,8 +71,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	 */
 	@Override
 	@Deprecated
-	public boolean addAll(Collection<? extends CLASS_TYPE> c)
+	public boolean addAll(Collection<? extends CLASS_TYPE> c) {
-	{
 		return c instanceof COLLECTION ? addAll((COLLECTION KEY_GENERIC_TYPE)c) : addAll(size(), c);
 	}
 	
@@ -221,6 +225,11 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		return new SubList(this, 0, fromIndex, toIndex);
 	}
 	
+	@Override
+	public LIST KEY_GENERIC_TYPE reversed() {
+		return new ReversedList(this);
+	}
+	
 	@Override
 	public ITERATOR KEY_GENERIC_TYPE iterator() {
 		return listIterator(0);
@@ -230,13 +239,25 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	public LIST_ITERATOR KEY_GENERIC_TYPE listIterator() {
 		return listIterator(0);
 	}
-
+		
 	@Override
 	public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index) {
 		if(index < 0 || index > size()) throw new IndexOutOfBoundsException();
 		return new LIST_ITER(index);
 	}
 	
+	@Override
+	public LIST_ITERATOR KEY_GENERIC_TYPE indexedIterator(int...indecies) {
+		return new IndexedIterator(indecies);
+	}
+	
+#if INT_LIST_MODULE
+	@Override
+	public LIST_ITERATOR KEY_GENERIC_TYPE indexedIterator(IntList indecies) {
+		return new ListIndexedIterator(indecies);
+	}
+	
+#endif
 	@Override
 	public void size(int size) {
 		while(size > size()) add(EMPTY_KEY_VALUE);
@@ -245,6 +266,138 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	
 	public ABSTRACT_LIST KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	
+	private class ReversedList extends ABSTRACT_LIST KEY_GENERIC_TYPE
+	{
+		final ABSTRACT_LIST KEY_GENERIC_TYPE list;
+		
+		public ReversedList(ABSTRACT_LIST KEY_GENERIC_TYPE list) {
+			this.list = list;
+		}
+
+		@Override
+		public void add(int index, KEY_TYPE e) {
+			list.add(list.size() - index - 1, e);
+		}
+		
+		@Override
+		public boolean addAll(int index, COLLECTION KEY_GENERIC_TYPE c) {
+			return addCollection(index, c);
+		}
+		
+		@Override
+		public boolean addAll(int index, LIST KEY_GENERIC_TYPE c) {
+			if(c instanceof RandomAccess) {
+				for(int i = 0,m=c.size();i<m;i++) {
+					list.add(list.size() - index - i - 1, c.GET_KEY(i));
+				}
+				return true;
+			}
+			return addCollection(index, c);
+		}
+		
+		private boolean addCollection(int index, COLLECTION KEY_GENERIC_TYPE c) {
+			int i = 0;
+			for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();i++) {
+				list.add(list.size() - index - i - 1, iter.NEXT());
+			}
+			return true;
+		}
+		
+		@Override
+		public boolean addAll(int index, Collection<? extends CLASS_TYPE> c) {
+			int i = 0;
+			for(Iterator<? extends CLASS_TYPE> iter = c.iterator();iter.hasNext();i++) {
+				list.add(list.size() - index - i - 1, iter.next());
+			}
+			return true;
+		}
+		
+		@Override
+		public KEY_TYPE GET_KEY(int index) {
+			return list.GET_KEY(list.size() - index - 1);
+		}
+
+		@Override
+		public KEY_TYPE set(int index, KEY_TYPE e) {
+			return list.set(list.size() - index - 1, e);
+		}
+
+		@Override
+		public KEY_TYPE REMOVE(int index) {
+			return list.REMOVE(list.size() - index - 1);
+		}
+		
+		@Override
+		public void addElements(int from, KEY_TYPE[] a, int offset, int length) {
+			for(int i = 0,m=length;i<m;i++) {
+				list.add(list.size() - from - i - 1, a[i+offset]);
+			}
+		}
+		
+		@Override
+		public KEY_TYPE[] getElements(int from, KEY_TYPE[] a, int offset, int length) {
+			return reverse(list.getElements(list.size() - from - 1, a, offset, length));
+		}
+
+		@Override
+		public void removeElements(int from, int to) {
+			list.removeElements(list.size() - to - 1, list.size() - from - 1);
+		}
+
+		@Override
+		public KEY_TYPE swapRemove(int index) {
+			return list.swapRemove(list.size() - index - 1);
+		}
+#if TYPE_OBJECT
+		@Override
+		public <K> K[] extractElements(int from, int to, Class<K> type) {
+			return reverse(list.extractElements(list.size() - to - 1, list.size() - from - 1, type));
+		}
+		
+#else
+		@Override
+		public KEY_TYPE[] extractElements(int from, int to) {
+			return reverse(list.extractElements(list.size() - to - 1, list.size() - from - 1));
+		}
+		
+#endif
+		@Override
+		public int size() {
+			return list.size();
+		}
+		
+		@Override
+		public void clear() {
+			list.clear();
+		}
+		
+		@Override
+		public LIST KEY_GENERIC_TYPE reversed() {
+			return list;
+		}
+		
+#if TYPE_OBJECT
+		private <K> K[] reverse(K[] data) {
+			for (int i = 0, mid = data.length >> 1, j = data.length - 1; i < mid; i++, j--) {
+				K t = data[i];
+				data[i] = data[j];
+				data[j] = t;
+			}
+			return data;
+		}
+#else
+		private KEY_TYPE[] reverse(KEY_TYPE[] data) {
+			for (int i = 0, mid = data.length >> 1, j = data.length - 1; i < mid; i++, j--) {
+				KEY_TYPE t = data[i];
+				data[i] = data[j];
+				data[j] = t;
+			}
+			return data;
+		}
+	
+#endif
+	}
+	
 	private class SubList extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	{
 		final ABSTRACT_LIST KEY_GENERIC_TYPE list;
@@ -490,7 +643,155 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 			}
 		}
 	}
+	
+#if INT_LIST_MODULE
+	private class ListIndexedIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
+		IntList indecies;
+		int index;
+		int lastReturned = -1;
 		
+		ListIndexedIterator(IntList indecies) {
+			this.indecies = indecies;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return index < indecies.size();
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			int i = index++;
+			return GET_KEY((lastReturned = indecies.getInt(i)));
+		}
+		
+		@Override
+		public boolean hasPrevious() {
+			return index > 0;
+		}
+		
+		@Override
+		public KEY_TYPE PREVIOUS() {
+			if(!hasPrevious()) throw new NoSuchElementException();
+			index--;
+			return GET_KEY((lastReturned = indecies.getInt(index)));
+		}
+		
+		@Override
+		public int nextIndex() {
+			return index;
+		}
+		
+		@Override
+		public int previousIndex() {
+			return index-1;
+		}
+		
+		@Override
+		public void remove() { throw new UnsupportedOperationException(); }
+		@Override
+		public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public void set(KEY_TYPE e) {
+			if(lastReturned == -1) throw new IllegalStateException();
+			ABSTRACT_LIST.this.set(lastReturned, e);
+		}
+		
+		@Override
+		public int skip(int amount) {
+			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
+			int steps = Math.min(amount, indecies.size() - index);
+			index += steps;
+			if(steps > 0) lastReturned = Math.min(index-1, indecies.size()-1);
+			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;
+			if(steps > 0) lastReturned = Math.max(index, 0);
+			return steps;
+		}
+	}
+	
+#endif
+	private class IndexedIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
+		int[] indecies;
+		int index;
+		int lastReturned = -1;
+		
+		IndexedIterator(int[] indecies) {
+			this.indecies = indecies;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return index < indecies.length;
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			int i = index++;
+			return GET_KEY((lastReturned = indecies[i]));
+		}
+		
+		@Override
+		public boolean hasPrevious() {
+			return index > 0;
+		}
+		
+		@Override
+		public KEY_TYPE PREVIOUS() {
+			if(!hasPrevious()) throw new NoSuchElementException();
+			index--;
+			return GET_KEY((lastReturned = indecies[index]));
+		}
+		
+		@Override
+		public int nextIndex() {
+			return index;
+		}
+		
+		@Override
+		public int previousIndex() {
+			return index-1;
+		}
+		
+		@Override
+		public void remove() { throw new UnsupportedOperationException(); }
+		@Override
+		public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public void set(KEY_TYPE e) {
+			if(lastReturned == -1) throw new IllegalStateException();
+			ABSTRACT_LIST.this.set(lastReturned, e);
+		}
+		
+		@Override
+		public int skip(int amount) {
+			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
+			int steps = Math.min(amount, indecies.length - index);
+			index += steps;
+			if(steps > 0) lastReturned = Math.min(index-1, indecies.length-1);
+			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;
+			if(steps > 0) lastReturned = Math.max(index, 0);
+			return steps;
+		}
+	}
+	
 	private class LIST_ITER implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		int index;
 		int lastReturned = -1;
@@ -568,7 +869,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
 			int steps = Math.min(amount, index);
 			index -= steps;
-			if(steps > 0) lastReturned = Math.min(index, size()-1);
+			if(steps > 0) lastReturned = Math.max(index, 0);
 			return steps;
 		}
 	}

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

@@ -13,8 +13,13 @@ import java.util.function.Consumer;
 #endif
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
+#if !TYPE_OBJECT && JDK_FUNCTION
+import java.util.function.PREDICATE;
+#endif
 #if PRIMITIVES
+#if !JDK_FUNCTION
 import java.util.function.JAVA_PREDICATE;
+#endif
 import java.util.function.JAVA_UNARY_OPERATOR;
 #endif
 
@@ -25,7 +30,9 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+#endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.objects.utils.ObjectArrays;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -131,7 +138,8 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 	
 	@Override
 	public KEY_TYPE[] getElements(int from, KEY_TYPE[] a, int offset, int length) {
-		SanityChecks.checkArrayCapacity(data.length, offset, length);
+		SanityChecks.checkArrayCapacity(a.length, offset, length);
+		SanityChecks.checkArrayCapacity(data.length, from, length);
 		System.arraycopy(data, from, a, offset, length);
 		return a;
 	}
@@ -438,6 +446,7 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 	@Override
 	@Primitive
 	public Object[] toArray() {
+		if(data.length == 0) return ObjectArrays.EMPTY_ARRAY;
 		Object[] obj = new Object[data.length];
 		for(int i = 0,m=data.length;i<m;i++)
 			obj[i] = KEY_TO_OBJ(data[i]);

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

@@ -3,10 +3,15 @@ package speiger.src.collections.PACKAGE.maps.abstracts;
 import java.util.AbstractMap;
 import java.util.Map;
 import java.util.Objects;
+#if VALUE_BOOLEAN && JDK_FUNCTION
+import java.util.function.PREDICATE;
+#endif
 
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
+#if !VALUE_BOOLEAN || !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
+#endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
@@ -196,6 +201,96 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 	@Override
 	public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
 		Objects.requireNonNull(mappingFunction);
+#if !VALUE_OBJECT
+		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, GET_VALUE(key));
+#else
+		VALUE_TYPE value = GET_VALUE(key);
+		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, value);
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			if(VALUE_EQUALS_NOT(value, getDefaultReturnValue()) || containsKey(key)) {
+				remove(key);
+				return getDefaultReturnValue();
+			}
+			return getDefaultReturnValue();
+		}
+#endif
+		put(key, newValue);
+		return newValue;
+	}
+	
+	@Override
+	public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if VALUE_OBJECT
+		VALUE_TYPE value;
+		if((value = GET_VALUE(key)) == getDefaultReturnValue() || !containsKey(key)) {
+			VALUE_TYPE newValue = mappingFunction.APPLY(key);
+			if(VALUE_EQUALS_NOT(newValue, getDefaultReturnValue())) {
+				put(key, newValue);
+				return newValue;
+			}
+		}
+		return value;
+#else
+		if(!containsKey(key)) {
+			VALUE_TYPE newValue = mappingFunction.APPLY(key);
+			put(key, newValue);
+			return newValue;
+		}
+		return get(key);
+#endif
+	}
+	
+	@Override
+	public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
+		Objects.requireNonNull(valueProvider);
+#if VALUE_OBJECT
+		VALUE_TYPE value;
+		if((value = GET_VALUE(key)) == getDefaultReturnValue() || !containsKey(key)) {
+			VALUE_TYPE newValue = valueProvider.VALUE_SUPPLY_GET();
+			if(VALUE_EQUALS_NOT(newValue, getDefaultReturnValue())) {
+				put(key, newValue);
+				return newValue;
+			}
+		}
+		return value;
+#else
+		if(!containsKey(key)) {
+			VALUE_TYPE newValue = valueProvider.VALUE_SUPPLY_GET();
+			put(key, newValue);
+			return newValue;
+		}
+		return get(key);
+#endif
+	}
+	
+	@Override
+	public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if VALUE_OBJECT
+		VALUE_TYPE value;
+		if(VALUE_EQUALS_NOT((value = GET_VALUE(key)), getDefaultReturnValue()) || containsKey(key)) {
+			VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, value);
+			if(VALUE_EQUALS_NOT(newValue, getDefaultReturnValue())) {
+				put(key, newValue);
+				return newValue;
+			}
+			remove(key);
+		}
+#else
+		if(containsKey(key)) {
+			VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, GET_VALUE(key));
+			put(key, newValue);
+			return newValue;
+		}
+#endif
+		return getDefaultReturnValue();
+	}
+	
+#if !VALUE_OBJECT
+	@Override
+	public VALUE_TYPE COMPUTENonDefault(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		VALUE_TYPE value = GET_VALUE(key);
 		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, value);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
@@ -210,7 +305,7 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 	}
 	
 	@Override
-	public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
+	public VALUE_TYPE COMPUTE_IF_ABSENTNonDefault(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
 		Objects.requireNonNull(mappingFunction);
 		VALUE_TYPE value;
 		if((value = GET_VALUE(key)) == getDefaultReturnValue() || !containsKey(key)) {
@@ -224,11 +319,11 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 	}
 	
 	@Override
-	public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
+	public VALUE_TYPE SUPPLY_IF_ABSENTNonDefault(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
 		Objects.requireNonNull(valueProvider);
 		VALUE_TYPE value;
 		if((value = GET_VALUE(key)) == getDefaultReturnValue() || !containsKey(key)) {
-			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
+			VALUE_TYPE newValue = valueProvider.VALUE_SUPPLY_GET();
 			if(VALUE_EQUALS_NOT(newValue, getDefaultReturnValue())) {
 				put(key, newValue);
 				return newValue;
@@ -238,7 +333,7 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 	}
 	
 	@Override
-	public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+	public VALUE_TYPE COMPUTE_IF_PRESENTNonDefault(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
 		Objects.requireNonNull(mappingFunction);
 		VALUE_TYPE value;
 		if(VALUE_EQUALS_NOT((value = GET_VALUE(key)), getDefaultReturnValue()) || containsKey(key)) {
@@ -251,7 +346,8 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 		}
 		return getDefaultReturnValue();
 	}
-
+	
+#endif
 	@Override
 	public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) {
 		Objects.requireNonNull(mappingFunction);

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

@@ -1,95 +1,95 @@
-package speiger.src.collections.PACKAGE.maps.interfaces;
+package speiger.src.collections.PACKAGE.maps.interfaces;
-
+
-import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ConcurrentMap;
-import java.util.function.BiConsumer;
+import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
+import java.util.function.BiFunction;
-import java.util.function.Function;
+import java.util.function.Function;
-
+
-/**
+/**
- * A type specific ConcurrentMap interface that reduces boxing/unboxing.
+ * A type specific ConcurrentMap interface that reduces boxing/unboxing.
- * Since the interface adds nothing new. It is there just for completion sake.
+ * Since the interface adds nothing new. It is there just for completion sake.
- * @Type(T)
+ * @Type(T)
- * @ValueType(V)
+ * @ValueType(V)
- */
+ */
-public interface CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE extends ConcurrentMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
+public interface CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE extends ConcurrentMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
-{
+{
-	@Override
+	@Override
-	@Primitive
+	@Primitive
-	public default CLASS_VALUE_TYPE compute(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+	public default CLASS_VALUE_TYPE compute(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
-		return MAP.super.compute(key, mappingFunction);
+		return MAP.super.compute(key, mappingFunction);
-	}
+	}
-
+
-	@Override
+	@Override
-	@Primitive
+	@Primitive
-	public default CLASS_VALUE_TYPE computeIfAbsent(CLASS_TYPE key, Function<? super CLASS_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+	public default CLASS_VALUE_TYPE computeIfAbsent(CLASS_TYPE key, Function<? super CLASS_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
-		return MAP.super.computeIfAbsent(key, mappingFunction);
+		return MAP.super.computeIfAbsent(key, mappingFunction);
-	}
+	}
-
+
-	@Override
+	@Override
-	@Primitive
+	@Primitive
-	public default CLASS_VALUE_TYPE computeIfPresent(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+	public default CLASS_VALUE_TYPE computeIfPresent(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
-		return MAP.super.computeIfPresent(key, mappingFunction);
+		return MAP.super.computeIfPresent(key, mappingFunction);
-	}
+	}
-
+
-	@Override
+	@Override
-	@Primitive
+	@Primitive
-	public default void forEach(BiConsumer<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE> action) {
+	public default void forEach(BiConsumer<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE> action) {
-		MAP.super.forEach(action);
+		MAP.super.forEach(action);
-	}
+	}
-
+
-	@Override
+	@Override
-	@Primitive
+	@Primitive
-	public default CLASS_VALUE_TYPE merge(CLASS_TYPE key, CLASS_VALUE_TYPE value, BiFunction<? super CLASS_VALUE_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+	public default CLASS_VALUE_TYPE merge(CLASS_TYPE key, CLASS_VALUE_TYPE value, BiFunction<? super CLASS_VALUE_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
-		return MAP.super.merge(key, value, mappingFunction);
+		return MAP.super.merge(key, value, mappingFunction);
-	}
+	}
-	
+	
-#if TYPE_OBJECT && VALUE_OBJECT
+#if TYPE_OBJECT && VALUE_OBJECT
-	@Override
+	@Override
-	public CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue);
+	public CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue);
-	@Override
+	@Override
-	public CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value);
+	public CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value);
-	@Override
+	@Override
-	public boolean remove(Object key, Object value);
+	public boolean remove(Object key, Object value);
-	@Override
+	@Override
-	public boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue);
+	public boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue);
-	@Override
+	@Override
-	public CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value);
+	public CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value);
-	
+	
-#else
+#else
-	@Primitive
+	@Primitive
-	@Override
+	@Override
-	public default CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue) {
+	public default CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue) {
-		return MAP.super.getOrDefault(key, defaultValue);
+		return MAP.super.getOrDefault(key, defaultValue);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@Primitive
+	@Primitive
-	public default CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
+	public default CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
-		return MAP.super.putIfAbsent(key, value);
+		return MAP.super.putIfAbsent(key, value);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@Deprecated
+	@Deprecated
-	public default boolean remove(Object key, Object value) {
+	public default boolean remove(Object key, Object value) {
-		return MAP.super.remove(key, value);
+		return MAP.super.remove(key, value);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@Deprecated
+	@Deprecated
-	public default boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue) {
+	public default boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue) {
-		return MAP.super.replace(key, oldValue, newValue);
+		return MAP.super.replace(key, oldValue, newValue);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@Deprecated
+	@Deprecated
-	public default CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
+	public default CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
-		return MAP.super.replace(key, value);
+		return MAP.super.replace(key, value);
-	}
+	}
-	
+	
-#endif
+#endif
-	@Override
+	@Override
-	@Deprecated
+	@Deprecated
-	public default void replaceAll(BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+	public default void replaceAll(BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
-		MAP.super.replaceAll(mappingFunction);
+		MAP.super.replaceAll(mappingFunction);
-	}
+	}
 }

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

@@ -10,6 +10,9 @@ import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
+#if VALUE_BOOLEAN && JDK_FUNCTION
+import java.util.function.PREDICATE;
+#endif
 
 #if TYPE_OBJECT
 #if AVL_TREE_MAP_FEATURE || RB_TREE_MAP_FEATURE
@@ -19,7 +22,9 @@ import java.util.Comparator;
 
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
+#if !VALUE_BOOLEAN || !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
+#endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !TYPE_OBJECT && !TYPE_BOOLEAN && SORTED_MAP_FEATURE
 #if AVL_TREE_MAP_FEATURE || RB_TREE_MAP_FEATURE
@@ -377,21 +382,26 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 	public void REPLACE_VALUES(UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction);
 	/**
 	 * A Type Specific compute method to reduce boxing/unboxing
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
 	 * @param key the key that should be computed
 	 * @param mappingFunction the operator that should generate the value
 	 * @return the result of the computation
 	 */
 	public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction);
 	/**
-	 * A Type Specific compute method to reduce boxing/unboxing
+	 * A Type Specific computeIfAbsent method to reduce boxing/unboxing
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
 	 * @param key the key that should be computed
 	 * @param mappingFunction the operator that should generate the value if not present
 	 * @return the result of the computed value or present value
 	 */
 	public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction);
-	
 	/**
 	 * A Supplier based computeIfAbsent function to fill the most used usecase of this function
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
 	 * @param key the key that should be computed
 	 * @param valueProvider the value if not present
 	 * @return the result of the computed value or present value
@@ -399,14 +409,57 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 	public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider);
 	/**
 	 * A Type Specific compute method to reduce boxing/unboxing
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
 	 * @param key the key that should be computed
 	 * @param mappingFunction the operator that should generate the value if present
 	 * @return the result of the default return value or present value
 	 * @note if not present then compute is not executed
 	 */
 	public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction);
+#if !VALUE_OBJECT
+	/**
+	 * A Type Specific compute method to reduce boxing/unboxing
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
+	 * @param key the key that should be computed
+	 * @param mappingFunction the operator that should generate the value
+	 * @return the result of the computation
+	 */
+	public VALUE_TYPE COMPUTENonDefault(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction);
+	/**
+	 * A Type Specific computeIfAbsent method to reduce boxing/unboxing
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
+	 * @param key the key that should be computed
+	 * @param mappingFunction the operator that should generate the value if not present
+	 * @return the result of the computed value or present value
+	 */
+	public VALUE_TYPE COMPUTE_IF_ABSENTNonDefault(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction);
+	/**
+	 * A Supplier based computeIfAbsent function to fill the most used usecase of this function
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
+	 * @param key the key that should be computed
+	 * @param valueProvider the value if not present
+	 * @return the result of the computed value or present value
+	 */	
+	public VALUE_TYPE SUPPLY_IF_ABSENTNonDefault(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider);
+	/**
+	 * A Type Specific compute method to reduce boxing/unboxing
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
+	 * @param key the key that should be computed
+	 * @param mappingFunction the operator that should generate the value if present
+	 * @return the result of the default return value or present value
+	 * @note if not present then compute is not executed
+	 */
+	public VALUE_TYPE COMPUTE_IF_PRESENTNonDefault(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction);
+#endif
 	/**
 	 * A Type Specific merge method to reduce boxing/unboxing
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
 	 * @param key the key that should be be searched for
 	 * @param value the value that should be merged with
 	 * @param mappingFunction the operator that should generate the new Value
@@ -416,6 +469,8 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 	public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction);
 	/**
 	 * A Bulk method for merging Maps.
+	 * If the generated value equals the getDefaultReturnValue it will simply not insert it since that is treated as "null".
+	 * A "Null Value" will be treated as "Do not insert/remove" based on how the Java has specified it.
 	 * @param m the entries that should be bulk added
 	 * @param mappingFunction the operator that should generate the new Value
 	 * @note if the result matches the default return value then the key is removed from the map

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

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

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

@@ -1,444 +1,468 @@
-package speiger.src.collections.PACKAGE.queues;
+package speiger.src.collections.PACKAGE.queues;
-
+
-import java.util.Arrays;
+import java.util.Arrays;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.Comparator;
+import java.util.Comparator;
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-import java.util.function.BiFunction;
+import java.util.function.BiFunction;
-#endif
+#endif
-import java.util.Objects;
+import java.util.Objects;
-import java.util.NoSuchElementException;
+import java.util.NoSuchElementException;
-
+#if JDK_FUNCTION
-import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import java.util.function.PREDICATE;
-#if !TYPE_OBJECT
+#endif
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
+
-import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#endif
+#if !TYPE_OBJECT
-import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
-import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
-import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#endif
-import speiger.src.collections.utils.ITrimmable;
+import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-
+import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
-/**
+#if !JDK_FUNCTION
- * A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue)
+import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
- * Its specific implementation uses a backing array that grows and shrinks as it is needed.
+#endif
- * @Type(T)
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
- */
+import speiger.src.collections.utils.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 */
+ * A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue)
-	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+ * Its specific implementation uses a backing array that grows and shrinks as it is needed.
-	/** The Minimum Capacity that is allowed */
+ * @Type(T)
-	public static final int MIN_CAPACITY = 4;
+ */
-	/** The Backing array */
+public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_DEQUEUE KEY_GENERIC_TYPE, ITrimmable
-	protected transient KEY_TYPE[] array;
+{
-	/** The First Index pointer */
+	/** Max Possible ArraySize without the JVM Crashing */
-	protected int first;
+	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
-	/** The Last Index pointer */
+	/** The Minimum Capacity that is allowed */
-	protected int last;
+	public static final int MIN_CAPACITY = 4;
-	/** The Minimum Capacity of the Queue **/
+	/** The Backing array */
-	protected int minCapacity;
+	protected transient KEY_TYPE[] array;
-	
+	/** The First Index pointer */
-	/**
+	protected int first;
-	 * Constructor using a initial array
+	/** The Last Index pointer */
-	 * @param values the Array that should be used
+	protected int last;
-	 */
+	/** The Minimum Capacity of the Queue **/
-	public ARRAY_FIFO_QUEUE(KEY_TYPE[] values) {
+	protected int minCapacity;
-		this(values, 0, values.length);
+	
-	}
+	/**
-	
+	 * Constructor using a initial array
-	/**
+	 * @param values the Array that should be used
-	 * Constructor using a initial array
+	 */
-	 * @param values the Array that should be used
+	public ARRAY_FIFO_QUEUE(KEY_TYPE[] values) {
-	 * @param size the amount of elements that are in the initial array
+		this(values, 0, values.length);
-	 * @throws IllegalStateException if values is smaller then size
+	}
-	 */
+	
-	public ARRAY_FIFO_QUEUE(KEY_TYPE[] values, int size) {
+	/**
-		this(values, 0, size);
+	 * Constructor using a initial array
-	}
+	 * @param values the Array that should be used
-	
+	 * @param size the amount of elements that are in the initial array
-	/**
+	 * @throws IllegalStateException if values is smaller then size
-	 * Constructor using a initial array
+	 */
-	 * @param values the Array that should be used
+	public ARRAY_FIFO_QUEUE(KEY_TYPE[] values, int size) {
-	 * @param offset where to begin in the initial array
+		this(values, 0, size);
-	 * @param size the amount of elements that are in the initial array
+	}
-	 * @throws IllegalStateException if values is smaller then size
+	
-	 */
+	/**
-	public ARRAY_FIFO_QUEUE(KEY_TYPE[] values, int offset, int size) {
+	 * Constructor using a initial array
-		if (values.length < size) throw new IllegalArgumentException("Initial array (" + values.length + ") is smaller then the expected size (" + size + ")");
+	 * @param values the Array that should be used
-		if(values.length <= 0) values = NEW_KEY_ARRAY(MIN_CAPACITY);
+	 * @param offset where to begin in the initial array
-		else if(values.length < MIN_CAPACITY) values = Arrays.copyOf(values, MIN_CAPACITY);
+	 * @param size the amount of elements that are in the initial array
-		minCapacity = MIN_CAPACITY;
+	 * @throws IllegalStateException if values is smaller then size
-		array = values;
+	 */
-		first = offset;
+	public ARRAY_FIFO_QUEUE(KEY_TYPE[] values, int offset, int size) {
-		last = (offset + size) % array.length;
+		if (values.length < size) throw new IllegalArgumentException("Initial array (" + values.length + ") is smaller then the expected size (" + size + ")");
-		if(array.length == size) expand();
+		if(values.length <= 0) values = NEW_KEY_ARRAY(MIN_CAPACITY);
-	}
+		else if(values.length < MIN_CAPACITY) values = Arrays.copyOf(values, MIN_CAPACITY);
-	
+		minCapacity = MIN_CAPACITY;
-	/**
+		array = values;
-	 * Constructor with a Min Capacity
+		first = offset;
-	 * @param capacity the initial capacity of the backing array
+		last = (offset + size) % array.length;
-	 * @throws IllegalStateException if the initial size is smaller 0
+		if(array.length == size) expand();
-	 */
+	}
-	public ARRAY_FIFO_QUEUE(int capacity) {
+	
-		if (capacity < 0) throw new IllegalArgumentException("Initial capacity (" + capacity + ") is negative");
+	/**
-		array = NEW_KEY_ARRAY(Math.max(MIN_CAPACITY, capacity+1));
+	 * Constructor with a Min Capacity
-		minCapacity = array.length;
+	 * @param capacity the initial capacity of the backing array
-	}
+	 * @throws IllegalStateException if the initial size is smaller 0
-	
+	 */
-	/**
+	public ARRAY_FIFO_QUEUE(int capacity) {
-	 * Default Construtor
+		if (capacity < 0) throw new IllegalArgumentException("Initial capacity (" + capacity + ") is negative");
-	 */
+		array = NEW_KEY_ARRAY(Math.max(MIN_CAPACITY, capacity+1));
-	public ARRAY_FIFO_QUEUE() {
+		minCapacity = array.length;
-		this(MIN_CAPACITY);
+	}
-	}
+	
-	
+	/**
-	@Override
+	 * Default Construtor
-	public ITERATOR KEY_GENERIC_TYPE iterator() {
+	 */
-		return new Iter();
+	public ARRAY_FIFO_QUEUE() {
-	}
+		this(MIN_CAPACITY);
-	
+	}
-	@Override
+	
-	public int size() {
+	@Override
-		final int apparentLength = last - first;
+	public ITERATOR KEY_GENERIC_TYPE iterator() {
-		return apparentLength >= 0 ? apparentLength : array.length + apparentLength;
+		return new Iter();
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public void clear() {
+	public int size() {
-		if(first != last) {
+		final int apparentLength = last - first;
-#if TYPE_OBJECT
+		return apparentLength >= 0 ? apparentLength : array.length + apparentLength;
-			Arrays.fill(array, null);
+	}
-#endif
+	
-			first = last = 0;
+	@Override
-		}
+	public void clear() {
-		else if(first != 0) {
+		if(first != last) {
-			first = last = 0;
+#if TYPE_OBJECT
-		}
+			Arrays.fill(array, null);
-	}
+#endif
-	
+			first = last = 0;
-	@Override
+		}
-	public void enqueue(KEY_TYPE e) {
+		else if(first != 0) {
-		array[last++] = e;
+			first = last = 0;
-		if(last == array.length) last = 0;
+		}
-		if(last == first) expand();
+	}
-	}
+	
-	
+	@Override
-	@Override
+	public void enqueue(KEY_TYPE e) {
-	public void enqueueFirst(KEY_TYPE e) {
+		array[last++] = e;
-		if(first == 0) first = array.length;
+		if(last == array.length) last = 0;
-		array[--first] = e;
+		if(last == first) expand();
-		if(first == last) expand();
+	}
-	}
+	
-	
+	@Override
-	@Override
+	public void enqueueFirst(KEY_TYPE e) {
-	public KEY_TYPE dequeue() {
+		if(first == 0) first = array.length;
-		if(first == last) throw new NoSuchElementException();
+		array[--first] = e;
-		KEY_TYPE data = array[first];
+		if(first == last) expand();
-#if TYPE_OBJECT
+	}
-		array[first] = null;
+	
-#endif
+	@Override
-		if(++first == array.length) first = 0;
+	public KEY_TYPE dequeue() {
-		reduce();
+		if(first == last) throw new NoSuchElementException();
-		return data;
+		KEY_TYPE data = array[first];
-	}
+#if TYPE_OBJECT
-	
+		array[first] = null;
-	@Override
+#endif
-	public KEY_TYPE dequeueLast() {
+		if(++first == array.length) first = 0;
-		if(first == last) throw new NoSuchElementException();
+		reduce();
-		if(last == 0) last = array.length;
+		return data;
-		KEY_TYPE data = array[--last];
+	}
-#if TYPE_OBJECT
+	
-		array[last] = null;
+	@Override
-#endif
+	public KEY_TYPE dequeueLast() {
-		reduce();
+		if(first == last) throw new NoSuchElementException();
-		return data;
+		if(last == 0) last = array.length;
-	}
+		KEY_TYPE data = array[--last];
-	
+#if TYPE_OBJECT
-	@Override
+		array[last] = null;
-	public KEY_TYPE peek(int index) {
+#endif
-		if(first == last || index < 0 || index >= size()) throw new NoSuchElementException();
+		reduce();
-		index += first;
+		return data;
-		return index >= array.length ? array[index-array.length] : array[index];
+	}
-	}
+	
-	
+	@Override
-	@Override
+	public KEY_TYPE peek(int index) {
-	public boolean removeFirst(KEY_TYPE e) {
+		if(first == last || index < 0 || index >= size()) throw new NoSuchElementException();
-		if(first == last) return false;
+		index += first;
-		for(int i = 0,m=size();i<m;i++) {
+		return index >= array.length ? array[index-array.length] : array[index];
-			int index = (first + i) % array.length;
+	}
-			if(e == array[index])
+	
-				return removeIndex(index);
+	@Override
-		}
+	public boolean contains(KEY_TYPE e) {
-		return false;
+		if(first == last) return false;
-	}
+		for(int i = 0,m=size();i<m;i++) {
-	
+			if(e == array[(first + i) % array.length]) return true;
-	@Override
+		}
-	public boolean removeLast(KEY_TYPE e) {
+		return false;
-		if(first == last) return false;
+	}
-		for(int i = size()-1;i>=0;i--) {
+	
-			int index = (first + i) % array.length;
+	@Override
-			if(e == array[index])
+	public boolean removeFirst(KEY_TYPE e) {
-				return removeIndex(index);
+		if(first == last) return false;
-		}
+		for(int i = 0,m=size();i<m;i++) {
-		return false;
+			int index = (first + i) % array.length;
-	}
+			if(e == array[index])
-	
+				return removeIndex(index);
-	protected boolean removeIndex(int index) {
+		}
-		if(first >= last ? index < first && index > last : index < first || index > last) return false;
+		return false;
-		if(index == first) {
+	}
-#if TYPE_OBJECT
+	
-			array[first] = null;
+	@Override
-#endif
+	public boolean removeLast(KEY_TYPE e) {
-			first++;
+		if(first == last) return false;
-		}
+		for(int i = size()-1;i>=0;i--) {
-		else if(index == last) {
+			int index = (first + i) % array.length;
-			last--;
+			if(e == array[index])
-#if TYPE_OBJECT
+				return removeIndex(index);
-			array[last] = null;
+		}
-#endif
+		return false;
-		}
+	}
-		else if(index > last) {
+	
-			System.arraycopy(array, first, array, first+1, (index - first));
+	protected boolean removeIndex(int index) {
-#if TYPE_OBJECT
+		if(first >= last ? index < first && index > last : index < first || index > last) return false;
-			array[first] = null;
+		if(index == first) {
-#endif
+#if TYPE_OBJECT
-			first = ++first % array.length;
+			array[first] = null;
-		}
+#endif
-		else if(index < first) {
+			first++;
-			System.arraycopy(array, index+1, array, index, (last - index) - 1);
+		}
-#if TYPE_OBJECT
+		else if(index == last) {
-			array[last] = null;
+			last--;
-#endif
+#if TYPE_OBJECT
-			if(--last < 0) last += array.length;
+			array[last] = null;
-		}
+#endif
-		else {
+		}
-			if(index - first < last - index) {
+		else if(index > last) {
-				System.arraycopy(array, first, array, first+1, (index - first));
+			System.arraycopy(array, first, array, first+1, (index - first));
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-				array[first] = null;
+			array[first] = null;
-#endif
+#endif
-				first = ++first % array.length;
+			first = ++first % array.length;
-			}
+		}
-			else {
+		else if(index < first) {
-				System.arraycopy(array, index+1, array, index, (last - index) - 1);
+			System.arraycopy(array, index+1, array, index, (last - index) - 1);
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-				array[last] = null;
+			array[last] = null;
-#endif
+#endif
-				if(--last < 0) last += array.length;
+			if(--last < 0) last += array.length;
-			}
+		}
-		}
+		else {
-		reduce();
+			if(index - first < last - index) {
-		return true;
+				System.arraycopy(array, first, array, first+1, (index - first));
-	}
+#if TYPE_OBJECT
-	
+				array[first] = null;
-	@Override
+#endif
-	public void onChanged() {}
+				first = ++first % array.length;
-	
+			}
-	@Override
+			else {
-	public ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE copy() {
+				System.arraycopy(array, index+1, array, index, (last - index) - 1);
-		ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_FIFO_QUEUEBRACES();
+#if TYPE_OBJECT
-		queue.first = first;
+				array[last] = null;
-		queue.last = last;
+#endif
-		queue.minCapacity = minCapacity;
+				if(--last < 0) last += array.length;
-		queue.array = Arrays.copyOf(array, array.length);
+			}
-		return queue;
+		}
-	}
+		reduce();
-	
+		return true;
-	@Override
+	}
-	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() { return null; }
+	
-	
+	@Override
-	@Override
+	public void onChanged() {}
-	public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
+	
-		Objects.requireNonNull(action);
+	@Override
-		if(first == last) return;
+	public ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE copy() {
-		for(int i = 0,m=size();i<m;i++)
+		ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_FIFO_QUEUEBRACES();
-			action.accept(array[(first + i) % array.length]);
+		queue.first = first;
-		clearAndTrim(0);
+		queue.last = last;
-	}
+		queue.minCapacity = minCapacity;
-	
+		queue.array = Arrays.copyOf(array, array.length);
-	@Override
+		return queue;
-	public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
+	}
-		Objects.requireNonNull(action);
+	
-		if(first == last) return;
+	@Override
-		for(int i = 0,m=size();i<m;i++)
+	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() { return null; }
-			action.accept(input, array[(first + i) % array.length]);
+	
-		clearAndTrim(0);	
+	@Override
-	}
+	public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
-	
+		Objects.requireNonNull(action);
-	@Override
+		if(first == last) return;
-	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
+		for(int i = 0,m=size();i<m;i++)
-		Objects.requireNonNull(filter);
+			action.accept(array[(first + i) % array.length]);
-		for(int i = 0,m=size();i<m;i++) {
+		clearAndTrim(0);
-			if(filter.test(array[(first + i) % array.length])) return true;
+	}
-		}
+	
-		return false;
+	@Override
-	}
+	public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
-	
+		Objects.requireNonNull(action);
-	@Override
+		if(first == last) return;
-	public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
+		for(int i = 0,m=size();i<m;i++)
-		Objects.requireNonNull(filter);
+			action.accept(i, array[(first + i) % array.length]);
-		for(int i = 0,m=size();i<m;i++) {
+		clearAndTrim(0);
-			if(filter.test(array[(first + i) % array.length])) return false;
+	}
-		}
+	
-		return true;
+	@Override
-	}
+	public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
-	
+		Objects.requireNonNull(action);
-	@Override
+		if(first == last) return;
-	public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
+		for(int i = 0,m=size();i<m;i++)
-		Objects.requireNonNull(filter);
+			action.accept(input, array[(first + i) % array.length]);
-		for(int i = 0,m=size();i<m;i++) {
+		clearAndTrim(0);	
-			if(!filter.test(array[(first + i) % array.length])) return false;
+	}
-		}
+	
-		return true;
+	@Override
-	}
+	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
-	
+		Objects.requireNonNull(filter);
-	@Override
+		for(int i = 0,m=size();i<m;i++) {
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+			if(filter.test(array[(first + i) % array.length])) return true;
-		Objects.requireNonNull(filter);
+		}
-		for(int i = 0,m=size();i<m;i++) {
+		return false;
-			int index = (first + i) % array.length;
+	}
-			if(filter.test(array[index])) {
+	
-				KEY_TYPE data = array[index];
+	@Override
-				removeIndex(index);
+	public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
-				return data;
+		Objects.requireNonNull(filter);
-			}
+		for(int i = 0,m=size();i<m;i++) {
-		}
+			if(filter.test(array[(first + i) % array.length])) return false;
-		return EMPTY_VALUE;
+		}
-	}
+		return true;
-	
+	}
-#if !TYPE_OBJECT
+	
-	@Override
+	@Override
-	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
-		Objects.requireNonNull(operator);
+		Objects.requireNonNull(filter);
-		KEY_TYPE state = identity;
+		for(int i = 0,m=size();i<m;i++) {
-		for(int i = 0,m=size();i<m;i++) {
+			if(!filter.test(array[(first + i) % array.length])) return false;
-			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
+		}
-		}
+		return true;
-		return state;
+	}
-	}
+	
-	
+	@Override
-#else
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
-	@Override
+		Objects.requireNonNull(filter);
-	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		for(int i = 0,m=size();i<m;i++) {
-		Objects.requireNonNull(operator);
+			int index = (first + i) % array.length;
-		KEY_SPECIAL_TYPE state = identity;
+			if(filter.test(array[index])) {
-		for(int i = 0,m=size();i<m;i++) {
+				KEY_TYPE data = array[index];
-			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
+				removeIndex(index);
-		}
+				return data;
-		return state;
+			}
-	}
+		}
-	
+		return EMPTY_VALUE;
-#endif
+	}
-	@Override
+	
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+#if !TYPE_OBJECT
-		Objects.requireNonNull(operator);
+	@Override
-		KEY_TYPE state = EMPTY_VALUE;
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-		boolean empty = true;
+		Objects.requireNonNull(operator);
-		for(int i = 0,m=size();i<m;i++) {
+		KEY_TYPE state = identity;
-			if(empty) {
+		for(int i = 0,m=size();i<m;i++) {
-				empty = false;
+			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
-				state = array[(first + i) % array.length];
+		}
-				continue;
+		return state;
-			}
+	}
-			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
+	
-		}
+#else
-		return state;
+	@Override
-	}
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
-	
+		Objects.requireNonNull(operator);
-	@Override
+		KEY_SPECIAL_TYPE state = identity;
-	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
+		for(int i = 0,m=size();i<m;i++) {
-		Objects.requireNonNull(filter);
+			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
-		int result = 0;
+		}
-		for(int i = 0,m=size();i<m;i++) {
+		return state;
-			if(filter.test(array[(first + i) % array.length])) result++;
+	}
-		}
+	
-		return result;
+#endif
-	}
+	@Override
-	
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-	@Override
+		Objects.requireNonNull(operator);
-	public boolean trim(int size) {
+		KEY_TYPE state = EMPTY_VALUE;
-		int newSize = Math.max(Math.max(size, size()), minCapacity);
+		boolean empty = true;
-		if(newSize >= array.length) return false;
+		for(int i = 0,m=size();i<m;i++) {
-		KEY_TYPE[] newArray = NEW_KEY_ARRAY(newSize);
+			if(empty) {
-		if(first <= last) System.arraycopy(array, first, newArray, 0, last - first);
+				empty = false;
-		else {
+				state = array[(first + i) % array.length];
-			System.arraycopy(array, first, newArray, 0, array.length - first);
+				continue;
-			System.arraycopy(array, 0, newArray, array.length - first, last);
+			}
-		}
+			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
-		first = 0;
+		}
-		last = size();
+		return state;
-		array = newArray;
+	}
-		return true;
+	
-	}
+	@Override
-	
+	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
-	/**
+		Objects.requireNonNull(filter);
-	 * Trims the collection down to the requested size and clears all elements while doing so
+		int result = 0;
-	 * @param size the amount of elements that should be allowed
+		for(int i = 0,m=size();i<m;i++) {
-	 * @note this will enforce minimum size of the collection itself
+			if(filter.test(array[(first + i) % array.length])) result++;
-	 */
+		}
-	@Override
+		return result;
-	public void clearAndTrim(int size) {
+	}
-		int newSize = Math.max(minCapacity, size);
+	
-		if(array.length <= newSize) {
+	@Override
-			clear();
+	public boolean trim(int size) {
-			return;
+		int newSize = Math.max(Math.max(size, size()), minCapacity);
-		}
+		if(newSize >= array.length) return false;
-		first = last = 0;
+		KEY_TYPE[] newArray = NEW_KEY_ARRAY(newSize);
-		array = NEW_KEY_ARRAY(newSize);
+		if(first <= last) System.arraycopy(array, first, newArray, 0, last - first);
-	}
+		else {
-	
+			System.arraycopy(array, first, newArray, 0, array.length - first);
-	@Override
+			System.arraycopy(array, 0, newArray, array.length - first, last);
-	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input) {
+		}
-		if(input == null || input.length < size()) input = NEW_SPECIAL_KEY_ARRAY(size());
+		first = 0;
-		if (first <= last) System.arraycopy(array, first, input, 0, last - first);
+		last = size();
-		else {
+		array = newArray;
-			System.arraycopy(array, first, input, 0, array.length - first);
+		return true;
-			System.arraycopy(array, 0, input, array.length - first, last);
+	}
-		}
+	
-		return input;
+	/**
-	}
+	 * Trims the collection down to the requested size and clears all elements while doing so
-	
+	 * @param size the amount of elements that should be allowed
-	protected void reduce() {
+	 * @note this will enforce minimum size of the collection itself
-		final int size = size();
+	 */
-		if (array.length > minCapacity && size <= array.length / 4) resize(size, Math.max(array.length / 2, minCapacity));
+	@Override
-	}
+	public void clearAndTrim(int size) {
-	
+		int newSize = Math.max(minCapacity, size);
-	protected void expand() {
+		if(array.length <= newSize) {
-		resize(array.length, (int)Math.min(MAX_ARRAY_SIZE, 2L * array.length));
+			clear();
-	}
+			return;
-	
+		}
-	protected final void resize(int oldSize, int newSize) {
+		first = last = 0;
-		KEY_TYPE[] newArray = NEW_KEY_ARRAY(newSize);
+		array = NEW_KEY_ARRAY(newSize);
-		if(first >= last) {
+	}
-			if(oldSize != 0)
+	
-			{
+	@Override
-				System.arraycopy(array, first, newArray, 0, array.length - first);
+	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input) {
-				System.arraycopy(array, 0, newArray, array.length - first, last);
+		if(input == null || input.length < size()) input = NEW_SPECIAL_KEY_ARRAY(size());
-			}
+		if (first <= last) System.arraycopy(array, first, input, 0, last - first);
-		}
+		else {
-		else System.arraycopy(array, first, newArray, 0, last-first);
+			System.arraycopy(array, first, input, 0, array.length - first);
-		first = 0;
+			System.arraycopy(array, 0, input, array.length - first, last);
-		last = oldSize;
+		}
-		array = newArray;
+		return input;
-	}
+	}
-	
+	
-	private class Iter implements ITERATOR KEY_GENERIC_TYPE
+	protected void reduce() {
-	{
+		final int size = size();
-		int index = first;
+		if (array.length > minCapacity && size <= array.length / 4) resize(size, Math.max(array.length / 2, minCapacity));
-		@Override
+	}
-		public boolean hasNext()
+	
-		{
+	protected void expand() {
-			return index != last;
+		resize(array.length, (int)Math.min(MAX_ARRAY_SIZE, 2L * array.length));
-		}
+	}
-
+	
-		@Override
+	protected final void resize(int oldSize, int newSize) {
-		public KEY_TYPE NEXT() {
+		KEY_TYPE[] newArray = NEW_KEY_ARRAY(newSize);
-			if(!hasNext()) throw new NoSuchElementException();
+		if(first >= last) {
-			KEY_TYPE value = array[index];
+			if(oldSize != 0)
-			removeIndex(index);
+			{
-			index = ++index % array.length;
+				System.arraycopy(array, first, newArray, 0, array.length - first);
-			return value;
+				System.arraycopy(array, 0, newArray, array.length - first, last);
-		}
+			}
-	}
+		}
+		else System.arraycopy(array, first, newArray, 0, last-first);
+		first = 0;
+		last = oldSize;
+		array = newArray;
+	}
+	
+	private class Iter implements ITERATOR KEY_GENERIC_TYPE
+	{
+		int index = first;
+		@Override
+		public boolean hasNext()
+		{
+			return index != last;
+		}
+
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			KEY_TYPE value = array[index];
+			removeIndex(index);
+			index = ++index % array.length;
+			return value;
+		}
+	}
 }

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

@@ -1,421 +1,447 @@
-package speiger.src.collections.PACKAGE.queues;
+package speiger.src.collections.PACKAGE.queues;
-
+
-import java.util.Arrays;
+import java.util.Arrays;
-import java.util.NoSuchElementException;
+import java.util.NoSuchElementException;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.Comparator;
+import java.util.Comparator;
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-import java.util.function.BiFunction;
+import java.util.function.BiFunction;
-#endif
+#endif
-import java.util.Objects;
+import java.util.Objects;
-
+#if JDK_FUNCTION
-import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import java.util.function.PREDICATE;
-import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#endif
-#if !TYPE_OBJECT
+
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
-import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#endif
+#if !TYPE_OBJECT
-import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
-import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
-import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#endif
-import speiger.src.collections.PACKAGE.utils.ARRAYS;
+import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-import speiger.src.collections.utils.SanityChecks;
+import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
-
+#if !JDK_FUNCTION
-/**
+import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
- * A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
+#endif
- * It allows for duplicated entries and works like {@link java.util.List#indexOf(Object)} search.
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
- * It is highly suggested to use HeapPriorityQueue otherwise, unless you know why you need this specific implementation
+import speiger.src.collections.PACKAGE.utils.ARRAYS;
- * @Type(T)
+import speiger.src.collections.utils.SanityChecks;
- */
+
-public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE
+/**
-{
+ * A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
-	/** The Backing Array */
+ * It allows for duplicated entries and works like {@link java.util.List#indexOf(Object)} search.
-	protected transient KEY_TYPE[] array = EMPTY_KEY_ARRAY;
+ * It is highly suggested to use HeapPriorityQueue otherwise, unless you know why you need this specific implementation
-	/** The Amount of elements stored within the array */
+ * @Type(T)
-	protected int size;
+ */
-	/** The Last known first index pointer */
+public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE
-	protected int firstIndex = -1;
+{
-	/** The Sorter of the Array */
+	/** The Backing Array */
-	protected COMPARATOR KEY_SUPER_GENERIC_TYPE comparator;
+	protected transient KEY_TYPE[] array = EMPTY_KEY_ARRAY;
-	
+	/** The Amount of elements stored within the array */
-	/**
+	protected int size;
-	 * Default Constructor
+	/** The Last known first index pointer */
-	 */
+	protected int firstIndex = -1;
-	public ARRAY_PRIORITY_QUEUE() {
+	/** The Sorter of the Array */
-		this(0, null);
+	protected COMPARATOR KEY_SUPER_GENERIC_TYPE comparator;
-	}
+	
-	
+	/**
-	/**
+	 * Default Constructor
-	 * Constructor using custom sorter
+	 */
-	 * @param comp Comparator to sort the Array. Can be null
+	public ARRAY_PRIORITY_QUEUE() {
-	 */
+		this(0, null);
-	public ARRAY_PRIORITY_QUEUE(COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	}
-		this(0, comp);
+	
-	}
+	/**
-	
+	 * Constructor using custom sorter
-	/**
+	 * @param comp Comparator to sort the Array. Can be null
-	 * Constructor with a Min Capacity
+	 */
-	 * @param size the initial capacity of the backing array
+	public ARRAY_PRIORITY_QUEUE(COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * @throws IllegalStateException if the initial size is smaller 0
+		this(0, comp);
-	 */
+	}
-	public ARRAY_PRIORITY_QUEUE(int size) {
+	
-		this(size, null);
+	/**
-	}
+	 * Constructor with a Min Capacity
-	
+	 * @param size the initial capacity of the backing array
-	/**
+	 * @throws IllegalStateException if the initial size is smaller 0
-	 * Constructor with a Min Capacity and custom Sorter
+	 */
-	 * @param size the initial capacity of the backing array
+	public ARRAY_PRIORITY_QUEUE(int size) {
-	 * @param comp Comparator to sort the Array. Can be null
+		this(size, null);
-	 * @throws IllegalStateException if the initial size is smaller 0
+	}
-	 */
+	
-	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");
+	 * Constructor with a Min Capacity and custom Sorter
-		if(size > 0) array = NEW_KEY_ARRAY(size);
+	 * @param size the initial capacity of the backing array
-		comparator = comp;
+	 * @param comp Comparator to sort the Array. Can be null
-	}
+	 * @throws IllegalStateException if the initial size is smaller 0
-	
+	 */
-	/**
+	public ARRAY_PRIORITY_QUEUE(int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * Constructor using a initial array
+		if(size < 0) throw new IllegalAccessError("Size has to be 0 or positive");
-	 * @param array the Array that should be used
+		if(size > 0) array = NEW_KEY_ARRAY(size);
-	 */
+		comparator = comp;
-	public ARRAY_PRIORITY_QUEUE(KEY_TYPE[] array) {
+	}
-		this(array, array.length);
+	
-	}
+	/**
-	
+	 * Constructor using a initial array
-	/**
+	 * @param array the Array that should be used
-	 * Constructor using a initial array
+	 */
-	 * @param array the Array that should be used
+	public ARRAY_PRIORITY_QUEUE(KEY_TYPE[] array) {
-	 * @param size the amount of elements found within the array
+		this(array, array.length);
-	 * @throws NegativeArraySizeException if size is smaller then 0
+	}
-	 */
+	
-	public ARRAY_PRIORITY_QUEUE(KEY_TYPE[] array, int size) {
+	/**
-		this.array = Arrays.copyOf(array, size);
+	 * Constructor using a initial array
-		this.size = size;
+	 * @param array the Array that should be used
-	}
+	 * @param size the amount of elements found within the array
-	
+	 * @throws NegativeArraySizeException if size is smaller then 0
-	/**
+	 */
-	 * Constructor using a initial array and a custom sorter
+	public ARRAY_PRIORITY_QUEUE(KEY_TYPE[] array, int size) {
-	 * @param array the Array that should be used
+		this.array = Arrays.copyOf(array, size);
-	 * @param comp Comparator to sort the Array. Can be null
+		this.size = size;
-	 */
+	}
-	public ARRAY_PRIORITY_QUEUE(KEY_TYPE[] array, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	
-		this(array, array.length, comp);
+	/**
-	}
+	 * Constructor using a initial array and a custom sorter
-	
+	 * @param array the Array that should be used
-	/**
+	 * @param comp Comparator to sort the Array. Can be null
-	 * Constructor using a initial array and a custom sorter
+	 */
-	 * @param array the Array that should be used
+	public ARRAY_PRIORITY_QUEUE(KEY_TYPE[] array, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * @param size the amount of elements found within the array
+		this(array, array.length, comp);
-	 * @param comp Comparator to sort the Array. Can be null
+	}
-	 * @throws NegativeArraySizeException if size is smaller then 0
+	
-	 */
+	/**
-	public ARRAY_PRIORITY_QUEUE(KEY_TYPE[] array, int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	 * Constructor using a initial array and a custom sorter
-		this.array = Arrays.copyOf(array, size);
+	 * @param array the Array that should be used
-		this.size = size;
+	 * @param size the amount of elements found within the array
-		this.comparator = comp;
+	 * @param comp Comparator to sort the Array. Can be null
-	}
+	 * @throws NegativeArraySizeException if size is smaller then 0
-	
+	 */
-	/**
+	public ARRAY_PRIORITY_QUEUE(KEY_TYPE[] array, int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * Constructor using a Collection
+		this.array = Arrays.copyOf(array, size);
-	 * @param c the Collection that should be used
+		this.size = size;
-	 */
+		this.comparator = comp;
-	public ARRAY_PRIORITY_QUEUE(COLLECTION KEY_GENERIC_TYPE c) {
+	}
-		array = CAST_KEY_ARRAY c.TO_ARRAY();
+	
-		size = c.size();
+	/**
-	}
+	 * Constructor using a Collection
-	
+	 * @param c the Collection that should be used
-	/**
+	 */
-	 * Constructor using a Collection and a custom sorter
+	public ARRAY_PRIORITY_QUEUE(COLLECTION KEY_GENERIC_TYPE c) {
-	 * @param c the Collection that should be used
+		array = CAST_KEY_ARRAY c.TO_ARRAY();
-	 * @param comp Comparator to sort the Array. Can be null
+		size = c.size();
-	 */
+	}
-	public ARRAY_PRIORITY_QUEUE(COLLECTION KEY_GENERIC_TYPE c, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	
-		array = CAST_KEY_ARRAY c.TO_ARRAY();
+	/**
-		size = c.size();
+	 * Constructor using a Collection and a custom sorter
-		comparator = comp;
+	 * @param c the Collection that should be used
-	}
+	 * @param comp Comparator to sort the Array. Can be null
-	
+	 */
-	/**
+	public ARRAY_PRIORITY_QUEUE(COLLECTION KEY_GENERIC_TYPE c, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * Wrapping method to help serialization
+		array = CAST_KEY_ARRAY c.TO_ARRAY();
-	 * @param array the array that should be used
+		size = c.size();
-	 * @Type(T)
+		comparator = comp;
-	 * @return a ArrayPriorityQueue containing the original input array
+	}
-	 */
+	
-	public static GENERIC_KEY_BRACES ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array) { 
+	/**
-		return wrap(array, array.length);
+	 * Wrapping method to help serialization
-	}
+	 * @param array the array that should be used
-	
+	 * @Type(T)
-	/**
+	 * @return a ArrayPriorityQueue containing the original input array
-	 * Wrapping method to help serialization
+	 */
-	 * @param array the array that should be used
+	public static GENERIC_KEY_BRACES ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array) { 
-	 * @param size the amount of elements within the array
+		return wrap(array, array.length);
-	 * @Type(T)
+	}
-	 * @return a ArrayPriorityQueue containing the original input array
+	
-	 */
+	/**
-	public static GENERIC_KEY_BRACES ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, int size) {
+	 * Wrapping method to help serialization
-		ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_PRIORITY_QUEUEBRACES();
+	 * @param array the array that should be used
-		queue.array = array;
+	 * @param size the amount of elements within the array
-		queue.size = size;
+	 * @Type(T)
-		return queue;
+	 * @return a ArrayPriorityQueue containing the original input array
-	}
+	 */
-	
+	public static GENERIC_KEY_BRACES ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, int size) {
-	/**
+		ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_PRIORITY_QUEUEBRACES();
-	 * Wrapping method to help serialization, using a custom sorter
+		queue.array = array;
-	 * @param array the array that should be used
+		queue.size = size;
-	 * @param comp Comparator to sort the Array. Can be null
+		return queue;
-	 * @Type(T)
+	}
-	 * @return a ArrayPriorityQueue containing the original input array
+	
-	 */
+	/**
-	public static GENERIC_KEY_BRACES ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	 * Wrapping method to help serialization, using a custom sorter
-		return wrap(array, array.length, comp);
+	 * @param array the array that should be used
-	}
+	 * @param comp Comparator to sort the Array. Can be null
-	
+	 * @Type(T)
-	/**
+	 * @return a ArrayPriorityQueue containing the original input array
-	 * Wrapping method to help serialization, using a custom sorter
+	 */
-	 * @param array the array that should be used
+	public static GENERIC_KEY_BRACES ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * @param size the amount of elements within the array
+		return wrap(array, array.length, comp);
-	 * @param comp Comparator to sort the Array. Can be null
+	}
-	 * @Type(T)
+	
-	 * @return a ArrayPriorityQueue containing the original input array
+	/**
-	 */
+	 * Wrapping method to help serialization, using a custom sorter
-	public static GENERIC_KEY_BRACES ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	 * @param array the array that should be used
-		ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_PRIORITY_QUEUEBRACES(comp);
+	 * @param size the amount of elements within the array
-		queue.array = array;
+	 * @param comp Comparator to sort the Array. Can be null
-		queue.size = size;
+	 * @Type(T)
-		return queue;
+	 * @return a ArrayPriorityQueue containing the original input array
-	}
+	 */
-	
+	public static GENERIC_KEY_BRACES ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	@Override
+		ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_PRIORITY_QUEUEBRACES(comp);
-	public void enqueue(KEY_TYPE e) {
+		queue.array = array;
-		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (long)(array.length >> 1), (long)SanityChecks.MAX_ARRAY_SIZE), size+1));
+		queue.size = size;
-		if(firstIndex != -1){
+		return queue;
-			int compare = comparator == null ? COMPAREABLE_TO_KEY(e, array[firstIndex]) : comparator.compare(e, array[firstIndex]);
+	}
-			if(compare < 0) firstIndex = size;
+	
-			else if(compare > 0) firstIndex = -1;
+	@Override
-		}
+	public void enqueue(KEY_TYPE e) {
-		array[size++] = e;
+		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (long)(array.length >> 1), (long)SanityChecks.MAX_ARRAY_SIZE), size+1));
-	}
+		if(firstIndex != -1){
-	
+			int compare = comparator == null ? COMPAREABLE_TO_KEY(e, array[firstIndex]) : comparator.compare(e, array[firstIndex]);
-	@Override
+			if(compare < 0) firstIndex = size;
-	public KEY_TYPE dequeue() {
+			else if(compare > 0) firstIndex = -1;
-		if(size <= 0) throw new NoSuchElementException();
+		}
-		int index = findFirstIndex();
+		array[size++] = e;
-		KEY_TYPE value = array[index];
+	}
-		if(index != --size) System.arraycopy(array, index+1, array, index, size - index);
+	
-#if TYPE_OBJECT
+	@Override
-		array[size] = null;
+	public KEY_TYPE dequeue() {
-#endif
+		if(size <= 0) throw new NoSuchElementException();
-		firstIndex = -1;
+		int index = findFirstIndex();
-		return value;
+		KEY_TYPE value = array[index];
-	}
+		if(index != --size) System.arraycopy(array, index+1, array, index, size - index);
-	
+#if TYPE_OBJECT
-	@Override
+		array[size] = null;
-	public KEY_TYPE peek(int index) {
+#endif
-		if(index < 0 || index >= size) throw new NoSuchElementException();
+		firstIndex = -1;
-		return array[index];
+		return value;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public boolean removeFirst(KEY_TYPE e) {
+	public KEY_TYPE first() {
-		for(int i = 0;i<size;i++)
+		if(isEmpty()) throw new NoSuchElementException();
-			if(KEY_EQUALS(e, array[i])) return removeIndex(i);
+		if(firstIndex == -1) findFirstIndex();
-		return false;
+		return array[firstIndex];
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public boolean removeLast(KEY_TYPE e) {
+	public KEY_TYPE peek(int index) {
-		for(int i = size-1;i>=0;i--)
+		if(index < 0 || index >= size) throw new NoSuchElementException();
-			if(KEY_EQUALS(e, array[i])) return removeIndex(i);
+		return array[index];
-		return false;
+	}
-	}
+	
-	
+	@Override
-	protected boolean removeIndex(int index) {
+	public boolean contains(KEY_TYPE e) {
-		if(index != --size) System.arraycopy(array, index+1, array, index, size - index);
+		for(int i = 0;i<size;i++)
-#if TYPE_OBJECT
+			if(KEY_EQUALS(e, array[i])) return true;
-		array[size] = null;
+		return false;
-#endif
+	}
-		if(index == firstIndex) firstIndex = -1;
+	
-		else if(firstIndex != -1 && index >= firstIndex) firstIndex--;
+	@Override
-		return true;
+	public boolean removeFirst(KEY_TYPE e) {
-	}
+		for(int i = 0;i<size;i++)
-	
+			if(KEY_EQUALS(e, array[i])) return removeIndex(i);
-	@Override
+		return false;
-	public void onChanged() {
+	}
-		firstIndex = -1;
+	
-	}
+	@Override
-	
+	public boolean removeLast(KEY_TYPE e) {
-	@Override
+		for(int i = size-1;i>=0;i--)
-	public int size() {
+			if(KEY_EQUALS(e, array[i])) return removeIndex(i);
-		return size;
+		return false;
-	}
+	}
-	
+	
-	@Override
+	protected boolean removeIndex(int index) {
-	public void clear() {
+		if(index != --size) System.arraycopy(array, index+1, array, index, size - index);
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		Arrays.fill(array, null);
+		array[size] = null;
-#endif
+#endif
-		size = 0;
+		if(index == firstIndex) firstIndex = -1;
-	}
+		else if(firstIndex != -1 && index >= firstIndex) firstIndex--;
-	
+		return true;
-	@Override
+	}
-	public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
+	
-		Objects.requireNonNull(action);
+	@Override
-		for(int i = 0,m=size;i<m;i++) action.accept(dequeue());
+	public void onChanged() {
-	}
+		firstIndex = -1;
-	
+	}
-	@Override
+	
-	public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
+	@Override
-		Objects.requireNonNull(action);
+	public int size() {
-		for(int i = 0,m=size;i<m;i++) action.accept(input, dequeue());
+		return size;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
+	public void clear() {
-		Objects.requireNonNull(filter);
+#if TYPE_OBJECT
-		for(int i = 0;i<size;i++) {
+		Arrays.fill(array, null);
-			if(filter.test(array[i])) return true;
+#endif
-		}
+		size = 0;
-		return false;
+	}
-	}
+	
-	
+	@Override
-	@Override
+	public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
-	public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
+		Objects.requireNonNull(action);
-		Objects.requireNonNull(filter);
+		for(int i = 0,m=size;i<m;i++) action.accept(dequeue());
-		for(int i = 0;i<size;i++) {
+	}
-			if(filter.test(array[i])) return false;
+	
-		}
+	@Override
-		return true;
+	public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
-	}
+		Objects.requireNonNull(action);
-	
+		for(int i = 0,m=size;i<m;i++) action.accept(i, dequeue());
-	@Override
+	}
-	public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
+	
-		Objects.requireNonNull(filter);
+	@Override
-		for(int i = 0;i<size;i++) {
+	public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
-			if(!filter.test(array[i])) return false;
+		Objects.requireNonNull(action);
-		}
+		for(int i = 0,m=size;i<m;i++) action.accept(input, dequeue());
-		return true;
+	}
-	}
+	
-	
+	@Override
-#if !TYPE_OBJECT
+	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
-	@Override
+		Objects.requireNonNull(filter);
-	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		for(int i = 0;i<size;i++) {
-		Objects.requireNonNull(operator);
+			if(filter.test(array[i])) return true;
-		KEY_TYPE state = identity;
+		}
-		for(int i = 0;i<size;i++) {
+		return false;
-			state = operator.APPLY_VALUE(state, array[i]);
+	}
-		}
+	
-		return state;
+	@Override
-	}
+	public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
-	
+		Objects.requireNonNull(filter);
-#else
+		for(int i = 0;i<size;i++) {
-	@Override
+			if(filter.test(array[i])) return false;
-	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		}
-		Objects.requireNonNull(operator);
+		return true;
-		KEY_SPECIAL_TYPE state = identity;
+	}
-		for(int i = 0;i<size;i++) {
+	
-			state = operator.APPLY_VALUE(state, array[i]);
+	@Override
-		}
+	public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
-		return state;
+		Objects.requireNonNull(filter);
-	}
+		for(int i = 0;i<size;i++) {
-	
+			if(!filter.test(array[i])) return false;
-#endif
+		}
-	@Override
+		return true;
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	}
-		Objects.requireNonNull(operator);
+	
-		KEY_TYPE state = EMPTY_VALUE;
+#if !TYPE_OBJECT
-		boolean empty = true;
+	@Override
-		for(int i = 0;i<size;i++) {
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-			if(empty) {
+		Objects.requireNonNull(operator);
-				empty = false;
+		KEY_TYPE state = identity;
-				state = array[i];
+		for(int i = 0;i<size;i++) {
-				continue;
+			state = operator.APPLY_VALUE(state, array[i]);
-			}
+		}
-			state = operator.APPLY_VALUE(state, array[i]);
+		return state;
-		}
+	}
-		return state;
+	
-	}
+#else
-	
+	@Override
-	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		Objects.requireNonNull(operator);
-		Objects.requireNonNull(filter);
+		KEY_SPECIAL_TYPE state = identity;
-		for(int i = 0;i<size;i++) {
+		for(int i = 0;i<size;i++) {
-			if(filter.test(array[i])) {
+			state = operator.APPLY_VALUE(state, array[i]);
-				KEY_TYPE data = array[i];
+		}
-				removeIndex(i);
+		return state;
-				return data;
+	}
-			}
+	
-		}
+#endif
-		return EMPTY_VALUE;
+	@Override
-	}
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-	
+		Objects.requireNonNull(operator);
-	@Override
+		KEY_TYPE state = EMPTY_VALUE;
-	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
+		boolean empty = true;
-		Objects.requireNonNull(filter);
+		for(int i = 0;i<size;i++) {
-		int result = 0;
+			if(empty) {
-		for(int i = 0;i<size;i++) {
+				empty = false;
-			if(filter.test(array[i])) result++;
+				state = array[i];
-		}
+				continue;
-		return result;
+			}
-	}
+			state = operator.APPLY_VALUE(state, array[i]);
-	
+		}
-	@Override
+		return state;
-	public ITERATOR KEY_GENERIC_TYPE iterator() {
+	}
-		return new Iter();
+	
-	}
+	@Override
-	
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
-	@Override
+		Objects.requireNonNull(filter);
-	public ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE copy() {
+		for(int i = 0;i<size;i++) {
-		ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_PRIORITY_QUEUEBRACES();
+			if(filter.test(array[i])) {
-		queue.firstIndex = firstIndex;
+				KEY_TYPE data = array[i];
-		queue.size = size;
+				removeIndex(i);
-		queue.comparator = comparator;
+				return data;
-		queue.array = Arrays.copyOf(array, array.length);
+			}
-		return queue;
+		}
-	}
+		return EMPTY_VALUE;
-	
+	}
-	@Override
+	
-	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() {
+	@Override
-		return comparator;
+	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
-	}
+		Objects.requireNonNull(filter);
-	
+		int result = 0;
-	@Override
+		for(int i = 0;i<size;i++) {
-	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input) {
+			if(filter.test(array[i])) result++;
-		if(input == null || input.length < size()) input = NEW_SPECIAL_KEY_ARRAY(size());
+		}
-		System.arraycopy(array, 0, input, 0, size());
+		return result;
-		return input;
+	}
-	}
+	
-	
+	@Override
-	protected int findFirstIndex() {
+	public ITERATOR KEY_GENERIC_TYPE iterator() {
-		if(firstIndex == -1) {
+		return new Iter();
-			int index = size-1;
+	}
-			KEY_TYPE value = array[index];
+	
-			if(comparator == null) {
+	@Override
-				for(int i = index;i>=0;i--) {
+	public ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE copy() {
-					if(COMPAREABLE_TO_KEY(array[i], value) < 0) 
+		ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new ARRAY_PRIORITY_QUEUEBRACES();
-						value = array[index = i];
+		queue.firstIndex = firstIndex;
-				}
+		queue.size = size;
-			}
+		queue.comparator = comparator;
-			else {
+		queue.array = Arrays.copyOf(array, array.length);
-				for(int i = index;i>=0;i--) {
+		return queue;
-					if(comparator.compare(array[i], value) < 0) 
+	}
-						value = array[index = i];
+	
-				}
+	@Override
-			}
+	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() {
-			firstIndex = index;
+		return comparator;
-		}
+	}
-		return firstIndex;
+	
-	}
+	@Override
-	
+	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input) {
-	private class Iter implements ITERATOR KEY_GENERIC_TYPE {
+		if(input == null || input.length < size()) input = NEW_SPECIAL_KEY_ARRAY(size());
-		@Override
+		System.arraycopy(array, 0, input, 0, size());
-		public boolean hasNext() {
+		return input;
-			return !isEmpty();
+	}
-		}
+	
-		
+	protected int findFirstIndex() {
-		@Override
+		if(firstIndex == -1) {
-		public KEY_TYPE NEXT() {
+			int index = size-1;
-			if(!hasNext()) throw new NoSuchElementException();
+			KEY_TYPE value = array[index];
-			return dequeue();
+			if(comparator == null) {
-		}
+				for(int i = index;i>=0;i--) {
-	}
+					if(COMPAREABLE_TO_KEY(array[i], value) < 0) 
+						value = array[index = i];
+				}
+			}
+			else {
+				for(int i = index;i>=0;i--) {
+					if(comparator.compare(array[i], value) < 0) 
+						value = array[index = i];
+				}
+			}
+			firstIndex = index;
+		}
+		return firstIndex;
+	}
+	
+	private class Iter implements ITERATOR KEY_GENERIC_TYPE {
+		@Override
+		public boolean hasNext() {
+			return !isEmpty();
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			return dequeue();
+		}
+	}
 }

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

@@ -1,396 +1,415 @@
-package speiger.src.collections.PACKAGE.queues;
+package speiger.src.collections.PACKAGE.queues;
-
+
-import java.util.Arrays;
+import java.util.Arrays;
-import java.util.NoSuchElementException;
+import java.util.NoSuchElementException;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.Comparator;
+import java.util.Comparator;
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-import java.util.function.BiFunction;
+import java.util.function.BiFunction;
-#endif
+#endif
-import java.util.Objects;
+import java.util.Objects;
-
+#if JDK_FUNCTION
-import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import java.util.function.PREDICATE;
-import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#endif
-#if !TYPE_OBJECT
+
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
-import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
-#endif
+#if !TYPE_OBJECT
-import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
-import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
-import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#endif
-import speiger.src.collections.PACKAGE.utils.ARRAYS;
+import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-import speiger.src.collections.utils.SanityChecks;
+import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
-
+#if !JDK_FUNCTION
-/**
+import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
- * A Simple Heap base Priority Queue implementation
+#endif
- * It is a ArrayBased Alternative to TreeSets that has less object allocations
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
- * @Type(T)
+import speiger.src.collections.PACKAGE.utils.ARRAYS;
- */
+import speiger.src.collections.utils.SanityChecks;
-public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE
+
-{
+/**
-	/** The Backing Array */
+ * A Simple Heap base Priority Queue implementation
-	protected transient KEY_TYPE[] array = EMPTY_KEY_ARRAY;
+ * It is a ArrayBased Alternative to TreeSets that has less object allocations
-	/** The Amount of elements stored within the array */
+ * @Type(T)
-	protected int size;
+ */
-	/** The Sorter of the Array */
+public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE
-	protected COMPARATOR KEY_SUPER_GENERIC_TYPE comparator;
+{
-	
+	/** The Backing Array */
-	/**
+	protected transient KEY_TYPE[] array = EMPTY_KEY_ARRAY;
-	 * Default Constructor
+	/** The Amount of elements stored within the array */
-	 */
+	protected int size;
-	public HEAP_PRIORITY_QUEUE() {
+	/** The Sorter of the Array */
-		this(0, null);
+	protected COMPARATOR KEY_SUPER_GENERIC_TYPE comparator;
-	}
+	
-	
+	/**
-	/**
+	 * Default Constructor
-	 * Constructor using custom sorter
+	 */
-	 * @param comp Comparator to sort the Array. Can be null
+	public HEAP_PRIORITY_QUEUE() {
-	 */
+		this(0, null);
-	public HEAP_PRIORITY_QUEUE(COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	}
-		this(0, comp);
+	
-	}
+	/**
-	
+	 * Constructor using custom sorter
-	/**
+	 * @param comp Comparator to sort the Array. Can be null
-	 * Constructor with a Min Capacity
+	 */
-	 * @param size the initial capacity of the backing array
+	public HEAP_PRIORITY_QUEUE(COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * @throws IllegalStateException if the initial size is smaller 0
+		this(0, comp);
-	 */
+	}
-	public HEAP_PRIORITY_QUEUE(int size) {
+	
-		this(size, null);
+	/**
-	}
+	 * Constructor with a Min Capacity
-	
+	 * @param size the initial capacity of the backing array
-	/**
+	 * @throws IllegalStateException if the initial size is smaller 0
-	 * Constructor with a Min Capacity and custom Sorter
+	 */
-	 * @param size the initial capacity of the backing array
+	public HEAP_PRIORITY_QUEUE(int size) {
-	 * @param comp Comparator to sort the Array. Can be null
+		this(size, null);
-	 * @throws IllegalStateException if the initial size is smaller 0
+	}
-	 */
+	
-	public HEAP_PRIORITY_QUEUE(int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	/**
-		if(size > 0) array = NEW_KEY_ARRAY(size);
+	 * Constructor with a Min Capacity and custom Sorter
-		comparator = comp;
+	 * @param size the initial capacity of the backing array
-	}
+	 * @param comp Comparator to sort the Array. Can be null
-	
+	 * @throws IllegalStateException if the initial size is smaller 0
-	/**
+	 */
-	 * Constructor using a initial array
+	public HEAP_PRIORITY_QUEUE(int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * @param array the Array that should be used
+		if(size > 0) array = NEW_KEY_ARRAY(size);
-	 */
+		comparator = comp;
-	public HEAP_PRIORITY_QUEUE(KEY_TYPE[] array) {
+	}
-		this(array, array.length);
+	
-	}
+	/**
-	
+	 * Constructor using a initial array
-	/**
+	 * @param array the Array that should be used
-	 * Constructor using a initial array
+	 */
-	 * @param array the Array that should be used
+	public HEAP_PRIORITY_QUEUE(KEY_TYPE[] array) {
-	 * @param size the amount of elements found within the array
+		this(array, array.length);
-	 * @throws NegativeArraySizeException if size is smaller then 0
+	}
-	 */
+	
-	public HEAP_PRIORITY_QUEUE(KEY_TYPE[] array, int size) {
+	/**
-		this.array = Arrays.copyOf(array, size);
+	 * Constructor using a initial array
-		this.size = size;
+	 * @param array the Array that should be used
-		ARRAYS.heapify(array, size, null);
+	 * @param size the amount of elements found within the array
-	}
+	 * @throws NegativeArraySizeException if size is smaller then 0
-	
+	 */
-	/**
+	public HEAP_PRIORITY_QUEUE(KEY_TYPE[] array, int size) {
-	 * Constructor using a initial array and a custom sorter
+		this.array = Arrays.copyOf(array, size);
-	 * @param array the Array that should be used
+		this.size = size;
-	 * @param comp Comparator to sort the Array. Can be null
+		ARRAYS.heapify(array, size, null);
-	 */
+	}
-	public HEAP_PRIORITY_QUEUE(KEY_TYPE[] array, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	
-		this(array, array.length, comp);
+	/**
-	}
+	 * Constructor using a initial array and a custom sorter
-	
+	 * @param array the Array that should be used
-	/**
+	 * @param comp Comparator to sort the Array. Can be null
-	 * Constructor using a initial array and a custom sorter
+	 */
-	 * @param array the Array that should be used
+	public HEAP_PRIORITY_QUEUE(KEY_TYPE[] array, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * @param size the amount of elements found within the array
+		this(array, array.length, comp);
-	 * @param comp Comparator to sort the Array. Can be null
+	}
-	 * @throws NegativeArraySizeException if size is smaller then 0
+	
-	 */
+	/**
-	public HEAP_PRIORITY_QUEUE(KEY_TYPE[] array, int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	 * Constructor using a initial array and a custom sorter
-		this.array = Arrays.copyOf(array, size);
+	 * @param array the Array that should be used
-		this.size = size;
+	 * @param size the amount of elements found within the array
-		comparator = comp;
+	 * @param comp Comparator to sort the Array. Can be null
-		ARRAYS.heapify(array, size, comp);
+	 * @throws NegativeArraySizeException if size is smaller then 0
-	}
+	 */
-	
+	public HEAP_PRIORITY_QUEUE(KEY_TYPE[] array, int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	/**
+		this.array = Arrays.copyOf(array, size);
-	 * Constructor using a Collection
+		this.size = size;
-	 * @param c the Collection that should be used
+		comparator = comp;
-	 */
+		ARRAYS.heapify(array, size, comp);
-	public HEAP_PRIORITY_QUEUE(COLLECTION KEY_GENERIC_TYPE c) {
+	}
-		array = CAST_KEY_ARRAY c.TO_ARRAY();
+	
-		size = c.size();
+	/**
-		ARRAYS.heapify(array, size, null);
+	 * Constructor using a Collection
-	}
+	 * @param c the Collection that should be used
-	
+	 */
-	/**
+	public HEAP_PRIORITY_QUEUE(COLLECTION KEY_GENERIC_TYPE c) {
-	 * Constructor using a Collection and a custom sorter
+		array = CAST_KEY_ARRAY c.TO_ARRAY();
-	 * @param c the Collection that should be used
+		size = c.size();
-	 * @param comp Comparator to sort the Array. Can be null
+		ARRAYS.heapify(array, size, null);
-	 */
+	}
-	public HEAP_PRIORITY_QUEUE(COLLECTION KEY_GENERIC_TYPE c, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	
-		array = CAST_KEY_ARRAY c.TO_ARRAY();
+	/**
-		size = c.size();
+	 * Constructor using a Collection and a custom sorter
-		comparator = comp;
+	 * @param c the Collection that should be used
-		ARRAYS.heapify(array, size, comp);
+	 * @param comp Comparator to sort the Array. Can be null
-	}
+	 */
-	
+	public HEAP_PRIORITY_QUEUE(COLLECTION KEY_GENERIC_TYPE c, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	/**
+		array = CAST_KEY_ARRAY c.TO_ARRAY();
-	 * Wrapping method to help serialization
+		size = c.size();
-	 * @param array the array that should be used
+		comparator = comp;
-	 * @Type(T)
+		ARRAYS.heapify(array, size, comp);
-	 * @return a HeapPriorityQueue containing the original input array
+	}
-	 */
+	
-	public static GENERIC_KEY_BRACES HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array) { 
+	/**
-		return wrap(array, array.length);
+	 * Wrapping method to help serialization
-	}
+	 * @param array the array that should be used
-	
+	 * @Type(T)
-	/**
+	 * @return a HeapPriorityQueue containing the original input array
-	 * Wrapping method to help serialization
+	 */
-	 * @param array the array that should be used
+	public static GENERIC_KEY_BRACES HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array) { 
-	 * @param size the amount of elements within the array
+		return wrap(array, array.length);
-	 * @Type(T)
+	}
-	 * @return a HeapPriorityQueue containing the original input array
+	
-	 */
+	/**
-	public static GENERIC_KEY_BRACES HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, int size) {
+	 * Wrapping method to help serialization
-		HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new HEAP_PRIORITY_QUEUEBRACES();
+	 * @param array the array that should be used
-		queue.array = array;
+	 * @param size the amount of elements within the array
-		queue.size = size;
+	 * @Type(T)
-		ARRAYS.heapify(array, size, null);
+	 * @return a HeapPriorityQueue containing the original input array
-		return queue;
+	 */
-	}
+	public static GENERIC_KEY_BRACES HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, int size) {
-	
+		HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new HEAP_PRIORITY_QUEUEBRACES();
-	/**
+		queue.array = array;
-	 * Wrapping method to help serialization, using a custom sorter
+		queue.size = size;
-	 * @param array the array that should be used
+		ARRAYS.heapify(array, size, null);
-	 * @param comp Comparator to sort the Array. Can be null
+		return queue;
-	 * @Type(T)
+	}
-	 * @return a HeapPriorityQueue containing the original input array
+	
-	 */
+	/**
-	public static GENERIC_KEY_BRACES HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	 * Wrapping method to help serialization, using a custom sorter
-		return wrap(array, array.length, comp);
+	 * @param array the array that should be used
-	}
+	 * @param comp Comparator to sort the Array. Can be null
-	
+	 * @Type(T)
-	/**
+	 * @return a HeapPriorityQueue containing the original input array
-	 * Wrapping method to help serialization, using a custom sorter
+	 */
-	 * @param array the array that should be used
+	public static GENERIC_KEY_BRACES HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	 * @param size the amount of elements within the array
+		return wrap(array, array.length, comp);
-	 * @param comp Comparator to sort the Array. Can be null
+	}
-	 * @Type(T)
+	
-	 * @return a HeapPriorityQueue containing the original input array
+	/**
-	 */
+	 * Wrapping method to help serialization, using a custom sorter
-	public static GENERIC_KEY_BRACES HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
+	 * @param array the array that should be used
-		HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new HEAP_PRIORITY_QUEUEBRACES(comp);
+	 * @param size the amount of elements within the array
-		queue.array = array;
+	 * @param comp Comparator to sort the Array. Can be null
-		queue.size = size;
+	 * @Type(T)
-		ARRAYS.heapify(array, size, comp);
+	 * @return a HeapPriorityQueue containing the original input array
-		return queue;
+	 */
-	}
+	public static GENERIC_KEY_BRACES HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE wrap(KEY_TYPE[] array, int size, COMPARATOR KEY_SUPER_GENERIC_TYPE comp) {
-	
+		HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new HEAP_PRIORITY_QUEUEBRACES(comp);
-	@Override
+		queue.array = array;
-	public int size() {
+		queue.size = size;
-		return size;
+		ARRAYS.heapify(array, size, comp);
-	}
+		return queue;
-	
+	}
-	@Override
+	
-	public void clear() {
+	@Override
-#if TYPE_OBJECT
+	public int size() {
-		Arrays.fill(array, null);
+		return size;
-#endif
+	}
-		size = 0;
+	
-	}
+	@Override
-	
+	public void clear() {
-	@Override
+#if TYPE_OBJECT
-	public ITERATOR KEY_GENERIC_TYPE iterator() {
+		Arrays.fill(array, null);
-		return new Iter();
+#endif
-	}
+		size = 0;
-	
+	}
-	@Override
+	
-	public void enqueue(KEY_TYPE e) {
+	@Override
-		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (long)(array.length >> 1), (long)SanityChecks.MAX_ARRAY_SIZE), size+1));
+	public ITERATOR KEY_GENERIC_TYPE iterator() {
-		array[size++] = e;
+		return new Iter();
-		ARRAYS.shiftUp(array, size-1, comparator);
+	}
-	}
+	
-	
+	@Override
-	@Override
+	public void enqueue(KEY_TYPE e) {
-	public KEY_TYPE dequeue() {
+		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (long)(array.length >> 1), (long)SanityChecks.MAX_ARRAY_SIZE), size+1));
-		if(size <= 0) throw new NoSuchElementException();
+		array[size++] = e;
-		KEY_TYPE value = array[0];
+		ARRAYS.shiftUp(array, size-1, comparator);
-		array[0] = array[--size];
+	}
-#if TYPE_OBJECT
+	
-		array[size] = null;
+	@Override
-#endif
+	public KEY_TYPE dequeue() {
-		if(size != 0) ARRAYS.shiftDown(array, size, 0, comparator);
+		if(size <= 0) throw new NoSuchElementException();
-		return value;
+		KEY_TYPE value = array[0];
-	}
+		array[0] = array[--size];
-	
+#if TYPE_OBJECT
-	@Override
+		array[size] = null;
-	public KEY_TYPE peek(int index) {
+#endif
-		if(index < 0 || index >= size) throw new NoSuchElementException();
+		if(size != 0) ARRAYS.shiftDown(array, size, 0, comparator);
-		return array[index];
+		return value;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public boolean removeFirst(KEY_TYPE e) {
+	public KEY_TYPE peek(int index) {
-		for(int i = 0;i<size;i++)
+		if(index < 0 || index >= size) throw new NoSuchElementException();
-			if(KEY_EQUALS(e, array[i])) return removeIndex(i);
+		return array[index];
-		return false;
+	}
-	}
+	
-	
+	@Override
-	@Override
+	public boolean contains(KEY_TYPE e) {
-	public boolean removeLast(KEY_TYPE e) {
+		for(int i = 0;i<size;i++)
-		for(int i = size-1;i>=0;i--)
+			if(KEY_EQUALS(e, array[i])) return true;
-			if(KEY_EQUALS(e, array[i])) return removeIndex(i);
+		return false;
-		return false;
+	}
-	}
+	
-	
+	@Override
-	@Override
+	public boolean removeFirst(KEY_TYPE e) {
-	public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
+		for(int i = 0;i<size;i++)
-		Objects.requireNonNull(action);
+			if(KEY_EQUALS(e, array[i])) return removeIndex(i);
-		for(int i = 0,m=size;i<m;i++) action.accept(dequeue());
+		return false;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
+	public boolean removeLast(KEY_TYPE e) {
-		Objects.requireNonNull(action);
+		for(int i = size-1;i>=0;i--)
-		for(int i = 0,m=size;i<m;i++) action.accept(input, dequeue());
+			if(KEY_EQUALS(e, array[i])) return removeIndex(i);
-	}
+		return false;
-	
+	}
-	@Override
+	
-	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
+	@Override
-		Objects.requireNonNull(filter);
+	public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
-		for(int i = 0;i<size;i++) {
+		Objects.requireNonNull(action);
-			if(filter.test(array[i])) return true;
+		for(int i = 0,m=size;i<m;i++) action.accept(dequeue());
-		}
+	}
-		return false;
+	
-	}
+	@Override
-	
+	public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
-	@Override
+		Objects.requireNonNull(action);
-	public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
+		for(int i = 0,m=size;i<m;i++) action.accept(i, dequeue());
-		Objects.requireNonNull(filter);
+	}
-		for(int i = 0;i<size;i++) {
+	
-			if(filter.test(array[i])) return false;
+	@Override
-		}
+	public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
-		return true;
+		Objects.requireNonNull(action);
-	}
+		for(int i = 0,m=size;i<m;i++) action.accept(input, dequeue());
-	
+	}
-	@Override
+	
-	public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
+	@Override
-		Objects.requireNonNull(filter);
+	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
-		for(int i = 0;i<size;i++) {
+		Objects.requireNonNull(filter);
-			if(!filter.test(array[i])) return false;
+		for(int i = 0;i<size;i++) {
-		}
+			if(filter.test(array[i])) return true;
-		return true;
+		}
-	}
+		return false;
-	
+	}
-#if !TYPE_OBJECT
+	
-	@Override
+	@Override
-	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
-		Objects.requireNonNull(operator);
+		Objects.requireNonNull(filter);
-		KEY_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
-		for(int i = 0;i<size;i++) {
+			if(filter.test(array[i])) return false;
-			state = operator.APPLY_VALUE(state, array[i]);
+		}
-		}
+		return true;
-		return state;
+	}
-	}
+	
-	
+	@Override
-#else
+	public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
-	@Override
+		Objects.requireNonNull(filter);
-	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		for(int i = 0;i<size;i++) {
-		Objects.requireNonNull(operator);
+			if(!filter.test(array[i])) return false;
-		KEY_SPECIAL_TYPE state = identity;
+		}
-		for(int i = 0;i<size;i++) {
+		return true;
-			state = operator.APPLY_VALUE(state, array[i]);
+	}
-		}
+	
-		return state;
+#if !TYPE_OBJECT
-	}
+	@Override
-	
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-#endif
+		Objects.requireNonNull(operator);
-	@Override
+		KEY_TYPE state = identity;
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		for(int i = 0;i<size;i++) {
-		Objects.requireNonNull(operator);
+			state = operator.APPLY_VALUE(state, array[i]);
-		KEY_TYPE state = EMPTY_VALUE;
+		}
-		boolean empty = true;
+		return state;
-		for(int i = 0;i<size;i++) {
+	}
-			if(empty) {
+	
-				empty = false;
+#else
-				state = array[i];
+	@Override
-				continue;
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
-			}
+		Objects.requireNonNull(operator);
-			state = operator.APPLY_VALUE(state, array[i]);
+		KEY_SPECIAL_TYPE state = identity;
-		}
+		for(int i = 0;i<size;i++) {
-		return state;
+			state = operator.APPLY_VALUE(state, array[i]);
-	}
+		}
-	
+		return state;
-	@Override
+	}
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	
-		Objects.requireNonNull(filter);
+#endif
-		for(int i = 0;i<size;i++) {
+	@Override
-			if(filter.test(array[i])) {
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-				KEY_TYPE data = array[i];
+		Objects.requireNonNull(operator);
-				removeIndex(i);
+		KEY_TYPE state = EMPTY_VALUE;
-				return data;
+		boolean empty = true;
-			}
+		for(int i = 0;i<size;i++) {
-		}
+			if(empty) {
-		return EMPTY_VALUE;
+				empty = false;
-	}
+				state = array[i];
-	
+				continue;
-	@Override
+			}
-	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
+			state = operator.APPLY_VALUE(state, array[i]);
-		Objects.requireNonNull(filter);
+		}
-		int result = 0;
+		return state;
-		for(int i = 0;i<size;i++) {
+	}
-			if(filter.test(array[i])) result++;
+	
-		}
+	@Override
-		return result;
+	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
-	}
+		Objects.requireNonNull(filter);
-	
+		for(int i = 0;i<size;i++) {
-	protected boolean removeIndex(int index) {
+			if(filter.test(array[i])) {
-		array[index] = array[--size];
+				KEY_TYPE data = array[i];
-#if TYPE_OBJECT
+				removeIndex(i);
-		array[size] = null;
+				return data;
-#endif
+			}
-		if(size != index) ARRAYS.shiftDown(array, size, index, comparator);
+		}
-		return true;
+		return EMPTY_VALUE;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public void onChanged() {
+	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
-		if(size <= 0) return;
+		Objects.requireNonNull(filter);
-		ARRAYS.shiftDown(array, size, 0, comparator);
+		int result = 0;
-	}
+		for(int i = 0;i<size;i++) {
-	
+			if(filter.test(array[i])) result++;
-	@Override
+		}
-	public HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE copy() {
+		return result;
-		HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new HEAP_PRIORITY_QUEUEBRACES();
+	}
-		queue.size = size;
+	
-		queue.comparator = comparator;
+	protected boolean removeIndex(int index) {
-		queue.array = Arrays.copyOf(array, array.length);
+		array[index] = array[--size];
-		return queue;
+#if TYPE_OBJECT
-	}
+		array[size] = null;
-	
+#endif
-	@Override
+		if(size != index) ARRAYS.shiftDown(array, size, index, comparator);
-	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() {
+		return true;
-		return comparator;
+	}
-	}
+	
-	
+	@Override
-	@Override
+	public void onChanged() {
-	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input) {
+		if(size <= 0) return;
-		if(input == null || input.length < size()) input = NEW_SPECIAL_KEY_ARRAY(size());
+		ARRAYS.shiftDown(array, size, 0, comparator);
-		System.arraycopy(array, 0, input, 0, size());
+	}
-		return input;
+	
-	}
+	@Override
-	
+	public HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE copy() {
-	private class Iter implements ITERATOR KEY_GENERIC_TYPE {
+		HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE queue = new HEAP_PRIORITY_QUEUEBRACES();
-		@Override
+		queue.size = size;
-		public boolean hasNext() {
+		queue.comparator = comparator;
-			return !isEmpty();
+		queue.array = Arrays.copyOf(array, array.length);
-		}
+		return queue;
-		
+	}
-		@Override
+	
-		public KEY_TYPE NEXT() {
+	@Override
-			if(!hasNext()) throw new NoSuchElementException();
+	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator() {
-			return dequeue();
+		return comparator;
-		}
+	}
-	}
+	
+	@Override
+	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input) {
+		if(input == null || input.length < size()) input = NEW_SPECIAL_KEY_ARRAY(size());
+		System.arraycopy(array, 0, input, 0, size());
+		return input;
+	}
+	
+	private class Iter implements ITERATOR KEY_GENERIC_TYPE {
+		@Override
+		public boolean hasNext() {
+			return !isEmpty();
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			return dequeue();
+		}
+	}
 }

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

@@ -1,196 +1,203 @@
-package speiger.src.collections.PACKAGE.queues;
+package speiger.src.collections.PACKAGE.queues;
-
+
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.Comparator;
+import java.util.Comparator;
-import java.util.Collection;
+import java.util.Collection;
-import java.util.Iterator;
+import java.util.Iterator;
-
+import java.util.function.IntFunction;
-import speiger.src.collections.ints.functions.function.Int2ObjectFunction;
+#else
-#else
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
+#endif
-#endif
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
-import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
-import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#if QUEUES_FEATURE
-#if QUEUES_FEATURE
+import speiger.src.collections.PACKAGE.utils.PRIORITY_QUEUES;
-import speiger.src.collections.PACKAGE.utils.PRIORITY_QUEUES;
+#endif
-#endif
+
-
+
-
+/**
-/**
+ * A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
- * A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
+ * @Type(T)
- * @Type(T)
+ */
- */
+public interface PRIORITY_QUEUE KEY_GENERIC_TYPE extends ITERABLE KEY_GENERIC_TYPE
-public interface PRIORITY_QUEUE KEY_GENERIC_TYPE extends ITERABLE KEY_GENERIC_TYPE
+{
-{
+	/**
-	/**
+	 * @return true if the PriorityQueue is empty
-	 * @return true if the PriorityQueue is empty
+	 */
-	 */
+	public default boolean isEmpty() { return size() <= 0; }
-	public default boolean isEmpty() { return size() <= 0; }
+	/**
-	/**
+	 * @return the amount of elements that are stored in the PriorityQueue
-	 * @return the amount of elements that are stored in the PriorityQueue
+	 */
-	 */
+	public int size();
-	public int size();
+	/**
-	/**
+	 * clears all elements within the PriorityQueue,
-	 * clears all elements within the PriorityQueue,
+	 * this does not resize the backing arrays
-	 * this does not resize the backing arrays
+	 */
-	 */
+	public void clear();
-	public void clear();
+	
-	
+	/**
-	/**
+	 * Method to insert a element into the PriorityQueue
-	 * Method to insert a element into the PriorityQueue
+	 * @param e the element that should be inserted
-	 * @param e the element that should be inserted
+	 */
-	 */
+	public void enqueue(KEY_TYPE e);
-	public void enqueue(KEY_TYPE e);
+	
-	
+	/**
-	/**
+	 * Method to mass insert elements into the PriorityQueue
-	 * Method to mass insert elements into the PriorityQueue
+	 * @param e the elements that should be inserted
-	 * @param e the elements that should be inserted
+	 */
-	 */
+	public default void enqueueAll(KEY_TYPE... e) {
-	public default void enqueueAll(KEY_TYPE... e) {
+		enqueueAll(e, 0, e.length);
-		enqueueAll(e, 0, e.length);
+	}
-	}
+	
-	
+	/**
-	/**
+	 * Method to mass insert elements into the PriorityQueue
-	 * Method to mass insert elements into the PriorityQueue
+	 * @param e the elements that should be inserted
-	 * @param e the elements that should be inserted
+	 * @param length the amount of elements that should be inserted
-	 * @param length the amount of elements that should be inserted
+	 */
-	 */
+	public default void enqueueAll(KEY_TYPE[] e, int length) {
-	public default void enqueueAll(KEY_TYPE[] e, int length) {
+		enqueueAll(e, 0, length);
-		enqueueAll(e, 0, length);
+	}
-	}
+	
-	
+	/**
-	/**
+	 * Method to mass insert elements into the PriorityQueue
-	 * Method to mass insert elements into the PriorityQueue
+	 * @param e the elements that should be inserted
-	 * @param e the elements that should be inserted
+	 * @param offset the offset where in the array should be started
-	 * @param offset the offset where in the array should be started
+	 * @param length the amount of elements that should be inserted
-	 * @param length the amount of elements that should be inserted
+	 */
-	 */
+	public default void enqueueAll(KEY_TYPE[] e, int offset, int length) {
-	public default void enqueueAll(KEY_TYPE[] e, int offset, int length) {
+		for(int i = 0;i<length;i++) 
-		for(int i = 0;i<length;i++) 
+			enqueue(e[i+offset]);
-			enqueue(e[i+offset]);
+	}
-	}
+	
-	
+	/**
-	/**
+	 * Method to mass insert elements into the PriorityQueue
-	 * Method to mass insert elements into the PriorityQueue
+	 * @param c the elements that should be inserted from the Collection
-	 * @param c the elements that should be inserted from the Collection
+	 */
-	 */
+	public default void enqueueAll(COLLECTION KEY_GENERIC_TYPE c) {
-	public default void enqueueAll(COLLECTION KEY_GENERIC_TYPE c) {
+		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
-		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
+			enqueue(iter.NEXT());
-			enqueue(iter.NEXT());
+	}
-	}
+	
-	
+#if TYPE_OBJECT
-#if TYPE_OBJECT
+	/**
-	/**
+	 * Method to mass insert elements into the PriorityQueue
-	 * Method to mass insert elements into the PriorityQueue
+	 * This method exists to add support for Java Collections to make it more useable
-	 * This method exists to add support for Java Collections to make it more useable
+	 * @param c the elements that should be inserted from the Collection
-	 * @param c the elements that should be inserted from the Collection
+	 */
-	 */
+	public default void enqueueAll(Collection<? extends CLASS_TYPE> c) {
-	public default void enqueueAll(Collection<? extends CLASS_TYPE> c) {
+		for(Iterator<? extends CLASS_TYPE> iter = c.iterator();iter.hasNext();)
-		for(Iterator<? extends CLASS_TYPE> iter = c.iterator();iter.hasNext();)
+			enqueue(iter.next());
-			enqueue(iter.next());
+	}
-	}
+	
-	
+#endif
-#endif
+	
-	
+	/**
-	/**
+	 * Method to extract a element from the PriorityQueue
-	 * Method to extract a element from the PriorityQueue
+	 * @return a element from the Queue
-	 * @return a element from the Queue
+	 * @throws java.util.NoSuchElementException if no element is present
-	 * @throws java.util.NoSuchElementException if no element is present
+	 */
-	 */
+	public KEY_TYPE dequeue();
-	public KEY_TYPE dequeue();
+	
-	
+	/**
-	/**
+	 * Peeking function to see whats inside the queue.
-	 * Peeking function to see whats inside the queue.
+	 * @param index of the element that is requested to be viewed.
-	 * @param index of the element that is requested to be viewed.
+	 * @return the element that is requested
-	 * @return the element that is requested
+	 */
-	 */
+	public KEY_TYPE peek(int index);
-	public KEY_TYPE peek(int index);
+	/**
-	/**
+	 * Shows the element that is to be returned next
-	 * Shows the element that is to be returned next
+	 * @return the first element in the Queue
-	 * @return the first element in the Queue
+	 */
-	 */
+	public default KEY_TYPE first() { return peek(0); }
-	public default KEY_TYPE first() { return peek(0); }
+	
-	
+	/**
-	/**
+	 * Method to find out if a element is part of the queue
-	 * Removes the first found element in the queue
+	 * @param e the element that is searched for
-	 * @param e the element that should be removed
+	 * @return true if the element is in the queue
-	 * @return if a searched element was removed
+	 */
-	 */
+	public boolean contains(KEY_TYPE e);
-	public boolean removeFirst(KEY_TYPE e);
+	
-	/**
+	/**
-	 * Removes the last found element in the queue
+	 * Removes the first found element in the queue
-	 * @param e the element that should be removed
+	 * @param e the element that should be removed
-	 * @return if a searched element was removed
+	 * @return if a searched element was removed
-	 */
+	 */
-	public boolean removeLast(KEY_TYPE e);
+	public boolean removeFirst(KEY_TYPE e);
-	
+	/**
-	/**
+	 * Removes the last found element in the queue
-	 * Allows to notify the Queue to be revalidate its data
+	 * @param e the element that should be removed
-	 */
+	 * @return if a searched element was removed
-	public void onChanged();
+	 */
-	
+	public boolean removeLast(KEY_TYPE e);
-	/**
+	
-	 * 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.
+	 * Allows to notify the Queue to be revalidate its data
-	 * It can be compared to Cloneable but with less exception risk
+	 */
-	 * @return a Shallow Copy of the PriorityQueue
+	public void onChanged();
-	 * @note Wrappers and view PriorityQueues will not support this feature
+	
-	 */
+	/**
-	public PRIORITY_QUEUE KEY_GENERIC_TYPE copy();
+	 * 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 the sorter of the Queue, can be null
+	 * @return a Shallow Copy of the PriorityQueue
-	 */
+	 * @note Wrappers and view PriorityQueues will not support this feature
-	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator();
+	 */
-	
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE copy();
-#if TYPE_OBJECT
+	
-	/**
+	/**
-	 * @return draining iterator of the PriorityQueue
+	 * @return the sorter of the Queue, can be null
-	 */
+	 */
-	public ITERATOR KEY_GENERIC_TYPE iterator();
+	public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator();
-
+	
-#endif
+#if TYPE_OBJECT
-#if QUEUES_FEATURE
+	/**
-	/**
+	 * @return draining iterator of the PriorityQueue
-	 * Creates a Wrapped PriorityQueue that is Synchronized
+	 */
-	 * @return a new PriorityQueue that is synchronized
+	public ITERATOR KEY_GENERIC_TYPE iterator();
-	 * @see PRIORITY_QUEUES#synchronize
+
-	 */
+#endif
-	public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue() { return PRIORITY_QUEUES.synchronize(this); }
+#if QUEUES_FEATURE
-	
+	/**
-	/**
+	 * Creates a Wrapped PriorityQueue that is Synchronized
-	 * Creates a Wrapped PriorityQueue that is Synchronized
+	 * @return a new PriorityQueue that is synchronized
-	 * @param mutex is the controller of the synchronization block
+	 * @see PRIORITY_QUEUES#synchronize
-	 * @return a new PriorityQueue Wrapper that is synchronized
+	 */
-	 * @see PRIORITY_QUEUES#synchronize
+	public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue() { return PRIORITY_QUEUES.synchronize(this); }
-	 */
+	
-	public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue(Object mutex) { return PRIORITY_QUEUES.synchronize(this, mutex); }
+	/**
-
+	 * Creates a Wrapped PriorityQueue that is Synchronized
-#endif
+	 * @param mutex is the controller of the synchronization block
-	/**
+	 * @return a new PriorityQueue Wrapper that is synchronized
-	 * A method to drop the contents of the Queue without clearing the queue
+	 * @see PRIORITY_QUEUES#synchronize
-	 * @Type(E)
+	 */
-	 * @return the contents of the queue into a seperate array.
+	public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue(Object mutex) { return PRIORITY_QUEUES.synchronize(this, mutex); }
-	 */
+
-	public default GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY() { return TO_ARRAY(NEW_SPECIAL_KEY_ARRAY(size())); }
+#endif
-	/**
+	/**
-	 * A method to drop the contents of the Queue without clearing the queue
+	 * A method to drop the contents of the Queue without clearing the queue
-	 * @param input where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
+	 * @Type(E)
-	 * @Type(E)
+	 * @return the contents of the queue into a seperate array.
-	 * @return the contents of the queue into a seperate array.
+	 */
-	 * @note if the Type is generic then a Object Array is created instead of a Type Array
+	public default GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY() { return TO_ARRAY(NEW_SPECIAL_KEY_ARRAY(size())); }
-	 */
+	/**
-	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input);
+	 * A method to drop the contents of the Queue without clearing the queue
-#if TYPE_OBJECT
+	 * @param input where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
-	/**
+	 * @Type(E)
-	 * A Helper function that simplifies the process of creating a new Array.
+	 * @return the contents of the queue into a seperate array.
-	 * @param action the array creation function
+	 * @note if the Type is generic then a Object Array is created instead of a Type Array
-	 * @return an array containing all of the elements in this collection
+	 */
-	 * @see Collection#toArray(Object[])
+	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input);
-	 */
+#if TYPE_OBJECT
-	default KEY_TYPE[] TO_ARRAY(Int2ObjectFunction<KEY_TYPE[]> action) {
+	/**
-		return TO_ARRAY(action.apply(size()));
+	 * A Helper function that simplifies the process of creating a new Array.
-	}
+	 * @param action the array creation function
-#endif
+	 * @param <E> the returning arrayType
+	 * @return an array containing all of the elements in this collection
+	 * @see Collection#toArray(Object[])
+	 */
+	default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
+		return TO_ARRAY(action.apply(size()));
+	}
+#endif
 }

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

@@ -1,50 +1,50 @@
-package speiger.src.collections.PACKAGE.sets;
+package speiger.src.collections.PACKAGE.sets;
-
+
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.Objects;
+import java.util.Objects;
-#endif
+#endif
-import java.util.Set;
+import java.util.Set;
-
+
-import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
+import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
-import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
-
+
-/**
+/**
- * Abstract Type Specific Set that reduces boxing/unboxing
+ * Abstract Type Specific Set that reduces boxing/unboxing
- * @Type(T)
+ * @Type(T)
- */
+ */
-public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
+public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
-{
+{
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-	@Override
+	@Override
-	public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+	public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
+	
-#endif
+#endif
-	@Override
+	@Override
-	public abstract ITERATOR KEY_GENERIC_TYPE iterator();
+	public abstract ITERATOR KEY_GENERIC_TYPE iterator();
-	@Override
+	@Override
-	public ABSTRACT_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+	public ABSTRACT_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
-	
+	
-	@Override
+	@Override
-	public int hashCode() {
+	public int hashCode() {
-		int hashCode = 0;
+		int hashCode = 0;
-		ITERATOR KEY_GENERIC_TYPE i = iterator();
+		ITERATOR KEY_GENERIC_TYPE i = iterator();
-		while(i.hasNext())
+		while(i.hasNext())
-			hashCode += KEY_TO_HASH(i.NEXT());
+			hashCode += KEY_TO_HASH(i.NEXT());
-		return hashCode;
+		return hashCode;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public boolean equals(Object o) {
+	public boolean equals(Object o) {
-		if (o == this)
+		if (o == this)
-			return true;
+			return true;
-		if (!(o instanceof Set))
+		if (!(o instanceof Set))
-			return false;
+			return false;
-		Set<?> l = (Set<?>)o;
+		Set<?> l = (Set<?>)o;
-		if(l.size() != size()) return false;
+		if(l.size() != size()) return false;
-		try {
+		try {
-			return containsAll(l);
+			return containsAll(l);
-		} catch (ClassCastException | NullPointerException unused) {
+		} catch (ClassCastException | NullPointerException unused) {
-			return false;
+			return false;
-		}
+		}
-	}
+	}
-}
+}

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

@@ -9,15 +9,21 @@ import java.util.function.BiFunction;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.Set;
-#if PRIMITIVES
+#if JDK_FUNCTION
+import java.util.function.PREDICATE;
+#endif
+#if PRIMITIVES && !JDK_FUNCTION
 import java.util.function.JAVA_PREDICATE;
 #endif
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 
+import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+#endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -391,6 +397,12 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		for(int i = 0;i<size;action.accept(data[i++]));
 	}
 	
+	@Override
+	public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
+		Objects.requireNonNull(action);
+		for(int i = 0;i<size;action.accept(i, data[i++]));
+	}
+	
 	@Override
 	public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
 		Objects.requireNonNull(action);
@@ -539,6 +551,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	@Override
 	@Deprecated
 	public Object[] toArray() {
+		if(isEmpty()) return ObjectArrays.EMPTY_ARRAY;
 		Object[] obj = new Object[size()];
 		for(int i = 0;i<size();i++)
 			obj[i] = KEY_TO_OBJ(data[i]);

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

@@ -12,9 +12,20 @@ import java.util.function.Consumer;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #else
+import java.util.function.IntFunction;
 import java.util.function.BiFunction;
 import java.util.Comparator;
 
+#iterate
+#argument MAPPER Predicate ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction
+#argument BUILDER BooleanAsyncBuilder ByteAsyncBuilder ShortAsyncBuilder IntAsyncBuilder LongAsyncBuilder FloatAsyncBuilder DoubleAsyncBuilder
+#argument PACKAGE booleans bytes shorts ints longs floats doubles
+#argument CHECK BOOLEAN_ASYNC_MODULE BYTE_ASYNC_MODULE SHORT_ASYNC_MODULE INT_ASYNC_MODULE LONG_ASYNC_MODULE FLOAT_ASYNC_MODULE DOUBLE_ASYNC_MODULE
+#if CHECK
+import speiger.src.collections.objects.functions.function.MAPPER;
+import speiger.src.collections.PACKAGE.utils.BUILDER;
+#endif
+#enditerate
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERABLE;
 #if OBJECT_ASYNC_MODULE
@@ -22,7 +33,9 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.functions.TASK;
+#if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+#endif
 #if OBJECT_ASYNC_MODULE
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 #endif
@@ -58,7 +71,9 @@ import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
 #endif
 #endif
 #if !TYPE_BOOLEAN && BOOLEAN_ASYNC_MODULE
+#if !TYPE_OBJECT
 import speiger.src.collections.booleans.utils.BooleanAsyncBuilder;
+#endif
 import speiger.src.collections.booleans.utils.BooleanAsyncBuilder.BaseBooleanTask;
 #endif
 #if !TYPE_OBJECT && OBJECT_ASYNC_MODULE
@@ -66,9 +81,12 @@ import speiger.src.collections.objects.utils.ObjectAsyncBuilder;
 import speiger.src.collections.objects.utils.ObjectAsyncBuilder.BaseObjectTask;
 #endif
 #if !TYPE_INT && INT_ASYNC_MODULE
+#if !TYPE_OBJECT
 import speiger.src.collections.ints.utils.IntAsyncBuilder;
+#endif
 import speiger.src.collections.ints.utils.IntAsyncBuilder.BaseIntTask;
 #endif
+import speiger.src.collections.utils.ISizeProvider;
 import speiger.src.collections.utils.SanityChecks;
 
 /**
@@ -185,6 +203,25 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		return new ObjectAsyncBuilder<>(ITERABLES.arrayFlatMap(iterable, mapper));
 	}
 	
+#endif
+#if TYPE_OBJECT
+#iterate
+#argument BUILDER BooleanAsyncBuilder ByteAsyncBuilder ShortAsyncBuilder IntAsyncBuilder LongAsyncBuilder FloatAsyncBuilder DoubleAsyncBuilder
+#argument MAPPER Predicate ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction
+#argument TYPE Boolean Byte Short Int Long Float Double
+#argument CHECK BOOLEAN_ASYNC_MODULE BYTE_ASYNC_MODULE SHORT_ASYNC_MODULE INT_ASYNC_MODULE LONG_ASYNC_MODULE FLOAT_ASYNC_MODULE DOUBLE_ASYNC_MODULE
+#if CHECK
+	/**
+	 * Maps the elements to something else
+	 * @param mapper the mapping function
+	 * @return a new Builder Object with the mapped Iterable
+	 */
+	public BUILDER mapToTYPE(MAPPER<T> mapper) {
+		return new BUILDER(ITERABLES.mapToTYPE(iterable, mapper));
+	}
+	
+#endif
+#enditerate
 #endif
 	/**
 	 * Filters out the unwanted elements out of the Iterable
@@ -292,6 +329,26 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	
 #endif
 #if OBJECT_ASYNC_MODULE
+#if TYPE_OBJECT
+	/**
+	 * Pours all elements of the Iterable down into a Array.
+	 * @param action creates the final array that should be copied into.
+	 * @return a new Builder with the ToArray function applied
+	 */
+	public ObjectAsyncBuilder<KEY_TYPE[]> TO_ARRAY(IntFunction<KEY_TYPE[]> action) {
+		return new ObjectAsyncBuilder<>(new ArrayTaskBRACES(iterable, action));
+	}
+	
+#else
+	/**
+	 * Pours all elements of the Iterable down into a Array.
+	 * @return a new Builder with the ToArray function applied
+	 */
+	public ObjectAsyncBuilder<KEY_TYPE[]> TO_ARRAY() {
+		return new ObjectAsyncBuilder<>(new ArrayTaskBRACES(iterable));
+	}
+	
+#endif
 #if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
 	/**
 	 * Pours all elements into a List that can be later
@@ -729,6 +786,52 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		}
 	}
 	
+	private static class ArrayTask KEY_GENERIC_TYPE extends BaseObjectTask<KEY_TYPE[]>
+	{
+		ITERATOR KEY_GENERIC_TYPE iter;
+		COLLECTIONS.CollectionWrapper KEY_GENERIC_TYPE wrapper;
+#if TYPE_OBJECT
+		IntFunction<KEY_TYPE[]> builder;
+		
+		public ArrayTask(ITERABLE KEY_GENERIC_TYPE iterable, IntFunction<KEY_TYPE[]> builder) {
+			this.builder = builder;
+#else
+	
+		public ArrayTask(ITERABLE KEY_GENERIC_TYPE iterable) {
+#endif
+			iter = iterable.iterator();
+			ISizeProvider prov = ISizeProvider.of(iterable);
+			int size = prov == null ? -1 : prov.size();
+			wrapper = size < 0 ? COLLECTIONS.wrapper() : COLLECTIONS.wrapper(size);
+		}
+		
+		@Override
+		protected boolean execute() throws Exception {
+			while(shouldRun() && iter.hasNext()) {
+				wrapper.add(iter.NEXT());
+			}
+			if(!iter.hasNext()) {
+#if TYPE_OBJECT
+				setResult(wrapper.TO_ARRAY(builder));
+#else
+				setResult(wrapper.TO_ARRAY());
+#endif
+				wrapper = null;
+				return true;
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onCompletion() {
+			super.onCompletion();
+			iter = null;
+#if TYPE_OBJECT
+			builder = null;
+#endif
+		}
+	}
+	
 	private static class ForEachTask<T> extends BaseObjectTask<Void>
 	{
 		ITERATOR KEY_GENERIC_TYPE iter;

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

@@ -5,6 +5,9 @@ import java.util.Collection;
 import java.util.Comparator;
 import java.util.function.Consumer;
 #endif
+#if JDK_FUNCTION
+import java.util.function.PREDICATE;
+#endif
 
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
@@ -18,7 +21,9 @@ import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
+#if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+#endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 
 /**
@@ -111,6 +116,8 @@ public class PRIORITY_QUEUES
 		@Override
 		public KEY_TYPE peek(int index) { synchronized(mutex) { return queue.peek(index); } }
 		@Override
+		public boolean contains(KEY_TYPE e) { synchronized(mutex) { return queue.contains(e); } }
+		@Override
 		public boolean removeFirst(KEY_TYPE e) { synchronized(mutex) { return queue.removeFirst(e); } }
 		@Override
 		public boolean removeLast(KEY_TYPE e) { synchronized(mutex) { return queue.removeLast(e); } }

src/builder/resources/speiger/assets/testers/templates/builder/DequeueTestSuiteBuilder.template

@@ -1,28 +1,28 @@
-package speiger.src.testers.PACKAGE.builder;
+package speiger.src.testers.PACKAGE.builder;
-
+
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-
+
-import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
-import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueDequeueTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueDequeueTester;
-import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueEnqueueTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueEnqueueTester;
-import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueLastTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueLastTester;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE extends QUEUE_TEST_BUILDER KEY_GENERIC_TYPE
+public class DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE extends QUEUE_TEST_BUILDER KEY_GENERIC_TYPE
-{
+{
-	public static GENERIC_KEY_BRACES DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE builder) {
+	public static GENERIC_KEY_BRACES DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE builder) {
-		return (DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE)new DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(builder);
+		return (DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE)new DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(builder);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> tester = super.getTesters();
+		List<Class<? extends AbstractTester>> tester = super.getTesters();
-		tester.add(FILE_KEY_TYPEDequeueDequeueTester.class);
+		tester.add(FILE_KEY_TYPEDequeueDequeueTester.class);
-		tester.add(FILE_KEY_TYPEDequeueEnqueueTester.class);
+		tester.add(FILE_KEY_TYPEDequeueEnqueueTester.class);
-		tester.add(FILE_KEY_TYPEDequeueLastTester.class);
+		tester.add(FILE_KEY_TYPEDequeueLastTester.class);
-		return tester;
+		return tester;
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/ListTestSuiteBuilder.template

@@ -1,384 +1,384 @@
-package speiger.src.testers.PACKAGE.builder;
+package speiger.src.testers.PACKAGE.builder;
-
+
-#ignore
+#ignore
-import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
+import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
-import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE;
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE;
-import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS;
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS;
-#endignore
+#endignore
-
+
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Collection;
-import java.util.HashSet;
+import java.util.HashSet;
-import java.util.List;
+import java.util.List;
-import java.util.Set;
+import java.util.Set;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
-import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.Helpers;
-import com.google.common.collect.testing.ListTestSuiteBuilder;
+import com.google.common.collect.testing.ListTestSuiteBuilder;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.SampleElements;
-import com.google.common.collect.testing.TestListGenerator;
+import com.google.common.collect.testing.TestListGenerator;
-import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionFeature;
-import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.features.Feature;
-import com.google.common.collect.testing.testers.CollectionSerializationEqualTester;
+import com.google.common.collect.testing.testers.CollectionSerializationEqualTester;
-import com.google.common.collect.testing.testers.ListAddAllAtIndexTester;
+import com.google.common.collect.testing.testers.ListAddAllAtIndexTester;
-import com.google.common.collect.testing.testers.ListAddAllTester;
+import com.google.common.collect.testing.testers.ListAddAllTester;
-import com.google.common.collect.testing.testers.ListAddAtIndexTester;
+import com.google.common.collect.testing.testers.ListAddAtIndexTester;
-import com.google.common.collect.testing.testers.ListAddTester;
+import com.google.common.collect.testing.testers.ListAddTester;
-import com.google.common.collect.testing.testers.ListCreationTester;
+import com.google.common.collect.testing.testers.ListCreationTester;
-import com.google.common.collect.testing.testers.ListEqualsTester;
+import com.google.common.collect.testing.testers.ListEqualsTester;
-import com.google.common.collect.testing.testers.ListGetTester;
+import com.google.common.collect.testing.testers.ListGetTester;
-import com.google.common.collect.testing.testers.ListHashCodeTester;
+import com.google.common.collect.testing.testers.ListHashCodeTester;
-import com.google.common.collect.testing.testers.ListIndexOfTester;
+import com.google.common.collect.testing.testers.ListIndexOfTester;
-import com.google.common.collect.testing.testers.ListLastIndexOfTester;
+import com.google.common.collect.testing.testers.ListLastIndexOfTester;
-import com.google.common.collect.testing.testers.ListRemoveAllTester;
+import com.google.common.collect.testing.testers.ListRemoveAllTester;
-import com.google.common.collect.testing.testers.ListRemoveAtIndexTester;
+import com.google.common.collect.testing.testers.ListRemoveAtIndexTester;
-import com.google.common.collect.testing.testers.ListRemoveTester;
+import com.google.common.collect.testing.testers.ListRemoveTester;
-import com.google.common.collect.testing.testers.ListReplaceAllTester;
+import com.google.common.collect.testing.testers.ListReplaceAllTester;
-import com.google.common.collect.testing.testers.ListRetainAllTester;
+import com.google.common.collect.testing.testers.ListRetainAllTester;
-import com.google.common.collect.testing.testers.ListSetTester;
+import com.google.common.collect.testing.testers.ListSetTester;
-import com.google.common.collect.testing.testers.ListSubListTester;
+import com.google.common.collect.testing.testers.ListSubListTester;
-import com.google.common.collect.testing.testers.ListToArrayTester;
+import com.google.common.collect.testing.testers.ListToArrayTester;
-import com.google.common.testing.SerializableTester;
+import com.google.common.testing.SerializableTester;
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.testers.base.tests.list.JavaListListIteratorTester;
+import speiger.src.testers.base.tests.list.JavaListListIteratorTester;
-import speiger.src.testers.PACKAGE.generators.TEST_LIST_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_LIST_GENERATOR;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAbsentTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAbsentTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllArrayAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllArrayAtIndexTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllAtIndexTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllListAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllListAtIndexTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAtIndexTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListCreationTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListCreationTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListEqualsTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListEqualsTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListExtractElementsTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListExtractElementsTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListGetElementsTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListGetElementsTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListGetTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListGetTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListIndexOfTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListIndexOfTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListLastIndexOfTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListLastIndexOfTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListListIteratorTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListListIteratorTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListPresentTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListPresentTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveAllTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveAllTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveAtIndexTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveElementsTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveElementsTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveTester;
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSortTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSortTester;
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListFillBufferTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListFillBufferTester;
-#endif
+#endif
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListReplaceAllTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListReplaceAllTester;
-#endif
+#endif
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRetainAllTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRetainAllTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSetTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSetTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSubListTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSubListTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSwapRemoveAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSwapRemoveAtIndexTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSwapRemoveTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSwapRemoveTester;
-import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListToArrayTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListToArrayTester;
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-import speiger.src.testers.utils.SpecialFeature;
+import speiger.src.testers.utils.SpecialFeature;
-#endif
+#endif
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class LIST_TEST_BUILDER KEY_GENERIC_TYPE extends COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE {
+public class LIST_TEST_BUILDER KEY_GENERIC_TYPE extends COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE {
-	
+	
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-	KEY_TYPE[] prefixes;
+	KEY_TYPE[] prefixes;
-	KEY_TYPE[] suffixes;
+	KEY_TYPE[] suffixes;
-#else
+#else
-	KEY_TYPE[] prefixes = createPrefixes();
+	KEY_TYPE[] prefixes = createPrefixes();
-	KEY_TYPE[] suffixes = createSuffixes();
+	KEY_TYPE[] suffixes = createSuffixes();
-#endif
+#endif
-	
+	
-	public static GENERIC_KEY_BRACES LIST_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_LIST_GENERATOR KEY_GENERIC_TYPE generator) {
+	public static GENERIC_KEY_BRACES LIST_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_LIST_GENERATOR KEY_GENERIC_TYPE generator) {
-		return (LIST_TEST_BUILDER KEY_GENERIC_TYPE) new LIST_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+		return (LIST_TEST_BUILDER KEY_GENERIC_TYPE) new LIST_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
-	}
+	}
-	
+	
-	public LIST_TEST_BUILDER KEY_GENERIC_TYPE setPrefixes(KEY_TYPE[] prefixes) {
+	public LIST_TEST_BUILDER KEY_GENERIC_TYPE setPrefixes(KEY_TYPE[] prefixes) {
-		this.prefixes = prefixes;
+		this.prefixes = prefixes;
-		return this;
+		return this;
-	}
+	}
-	
+	
-	public LIST_TEST_BUILDER KEY_GENERIC_TYPE setSuffixes(KEY_TYPE[] suffixes) {
+	public LIST_TEST_BUILDER KEY_GENERIC_TYPE setSuffixes(KEY_TYPE[] suffixes) {
-		this.suffixes = suffixes;
+		this.suffixes = suffixes;
-		return this;
+		return this;
-	}
+	}
-	
+	
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	public KEY_TYPE[] createPrefixes() {
+	public KEY_TYPE[] createPrefixes() {
-#if TYPE_BOOLEAN
+#if TYPE_BOOLEAN
-		return new KEY_TYPE[]{false, false, false};
+		return new KEY_TYPE[]{false, false, false};
-#else if TYPE_BYTE
+#else if TYPE_BYTE
-		return new KEY_TYPE[]{(byte)-3, (byte)-2, (byte)-1};
+		return new KEY_TYPE[]{(byte)-3, (byte)-2, (byte)-1};
-#else if TYPE_SHORT
+#else if TYPE_SHORT
-		return new KEY_TYPE[]{(short)-3, (short)-2, (short)-1};
+		return new KEY_TYPE[]{(short)-3, (short)-2, (short)-1};
-#else if TYPE_CHAR
+#else if TYPE_CHAR
-		return new KEY_TYPE[]{'^', '_', '`'};
+		return new KEY_TYPE[]{'^', '_', '`'};
-#else
+#else
-		return new KEY_TYPE[]{-3, -2, -1};
+		return new KEY_TYPE[]{-3, -2, -1};
-#endif
+#endif
-	}
+	}
-	
+	
-	public KEY_TYPE[] createSuffixes() {
+	public KEY_TYPE[] createSuffixes() {
-#if TYPE_BOOLEAN
+#if TYPE_BOOLEAN
-		return new KEY_TYPE[]{true, true, true};
+		return new KEY_TYPE[]{true, true, true};
-#else if TYPE_BYTE
+#else if TYPE_BYTE
-		return new KEY_TYPE[]{(byte)5, (byte)6, (byte)7};
+		return new KEY_TYPE[]{(byte)5, (byte)6, (byte)7};
-#else if TYPE_SHORT
+#else if TYPE_SHORT
-		return new KEY_TYPE[]{(short)5, (short)6, (short)7};
+		return new KEY_TYPE[]{(short)5, (short)6, (short)7};
-#else if TYPE_CHAR
+#else if TYPE_CHAR
-		return new KEY_TYPE[]{'f', 'g', 'h'};
+		return new KEY_TYPE[]{'f', 'g', 'h'};
-#else
+#else
-		return new KEY_TYPE[]{5, 6, 7};
+		return new KEY_TYPE[]{5, 6, 7};
-#endif
+#endif
-	}
+	}
-	
+	
-#endif
+#endif
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
-
+
-		testers.add(CollectionSerializationEqualTester.class);
+		testers.add(CollectionSerializationEqualTester.class);
-		testers.add(ListAddAllAtIndexTester.class);
+		testers.add(ListAddAllAtIndexTester.class);
-		testers.add(ListAddAllTester.class);
+		testers.add(ListAddAllTester.class);
-		testers.add(ListAddAtIndexTester.class);
+		testers.add(ListAddAtIndexTester.class);
-		testers.add(ListAddTester.class);
+		testers.add(ListAddTester.class);
-		testers.add(ListCreationTester.class);
+		testers.add(ListCreationTester.class);
-		testers.add(ListEqualsTester.class);
+		testers.add(ListEqualsTester.class);
-		testers.add(ListGetTester.class);
+		testers.add(ListGetTester.class);
-		testers.add(ListHashCodeTester.class);
+		testers.add(ListHashCodeTester.class);
-		testers.add(ListIndexOfTester.class);
+		testers.add(ListIndexOfTester.class);
-		testers.add(ListLastIndexOfTester.class);
+		testers.add(ListLastIndexOfTester.class);
-		testers.add(JavaListListIteratorTester.class);
+		testers.add(JavaListListIteratorTester.class);
-		testers.add(ListRemoveAllTester.class);
+		testers.add(ListRemoveAllTester.class);
-		testers.add(ListRemoveAtIndexTester.class);
+		testers.add(ListRemoveAtIndexTester.class);
-		testers.add(ListRemoveTester.class);
+		testers.add(ListRemoveTester.class);
-		testers.add(ListReplaceAllTester.class);
+		testers.add(ListReplaceAllTester.class);
-		testers.add(ListRetainAllTester.class);
+		testers.add(ListRetainAllTester.class);
-		testers.add(ListSetTester.class);
+		testers.add(ListSetTester.class);
-		testers.add(ListSubListTester.class);
+		testers.add(ListSubListTester.class);
-		testers.add(ListToArrayTester.class);
+		testers.add(ListToArrayTester.class);
-		
+		
-		testers.add(FILE_KEY_TYPEListAddAllAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListAddAllAtIndexTester.class);
-		testers.add(FILE_KEY_TYPEListAddAllListAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListAddAllListAtIndexTester.class);
-		testers.add(FILE_KEY_TYPEListAddAllArrayAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListAddAllArrayAtIndexTester.class);
-		testers.add(FILE_KEY_TYPEListAddAllTester.class);
+		testers.add(FILE_KEY_TYPEListAddAllTester.class);
-		testers.add(FILE_KEY_TYPEListAddAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListAddAtIndexTester.class);
-		testers.add(FILE_KEY_TYPEListAddTester.class);
+		testers.add(FILE_KEY_TYPEListAddTester.class);
-		testers.add(FILE_KEY_TYPEListAbsentTester.class);
+		testers.add(FILE_KEY_TYPEListAbsentTester.class);
-		testers.add(FILE_KEY_TYPEListPresentTester.class);
+		testers.add(FILE_KEY_TYPEListPresentTester.class);
-		testers.add(FILE_KEY_TYPEListCreationTester.class);
+		testers.add(FILE_KEY_TYPEListCreationTester.class);
-		testers.add(FILE_KEY_TYPEListEqualsTester.class);
+		testers.add(FILE_KEY_TYPEListEqualsTester.class);
-		testers.add(FILE_KEY_TYPEListGetTester.class);
+		testers.add(FILE_KEY_TYPEListGetTester.class);
-		testers.add(FILE_KEY_TYPEListGetElementsTester.class);
+		testers.add(FILE_KEY_TYPEListGetElementsTester.class);
-		testers.add(FILE_KEY_TYPEListExtractElementsTester.class);
+		testers.add(FILE_KEY_TYPEListExtractElementsTester.class);
-		testers.add(FILE_KEY_TYPEListIndexOfTester.class);
+		testers.add(FILE_KEY_TYPEListIndexOfTester.class);
-		testers.add(FILE_KEY_TYPEListLastIndexOfTester.class);
+		testers.add(FILE_KEY_TYPEListLastIndexOfTester.class);
-		testers.add(FILE_KEY_TYPEListListIteratorTester.class);
+		testers.add(FILE_KEY_TYPEListListIteratorTester.class);
-		testers.add(FILE_KEY_TYPEListRemoveAllTester.class);
+		testers.add(FILE_KEY_TYPEListRemoveAllTester.class);
-		testers.add(FILE_KEY_TYPEListRemoveAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListRemoveAtIndexTester.class);
-		testers.add(FILE_KEY_TYPEListRemoveTester.class);
+		testers.add(FILE_KEY_TYPEListRemoveTester.class);
-		testers.add(FILE_KEY_TYPEListRemoveElementsTester.class);
+		testers.add(FILE_KEY_TYPEListRemoveElementsTester.class);
-		testers.add(FILE_KEY_TYPEListSwapRemoveAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListSwapRemoveAtIndexTester.class);
-		testers.add(FILE_KEY_TYPEListSwapRemoveTester.class);
+		testers.add(FILE_KEY_TYPEListSwapRemoveTester.class);
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-		testers.add(FILE_KEY_TYPEListSortTester.class);
+		testers.add(FILE_KEY_TYPEListSortTester.class);
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-		testers.add(FILE_KEY_TYPEListFillBufferTester.class);
+		testers.add(FILE_KEY_TYPEListFillBufferTester.class);
-#endif
+#endif
-		testers.add(FILE_KEY_TYPEListReplaceAllTester.class);
+		testers.add(FILE_KEY_TYPEListReplaceAllTester.class);
-#endif
+#endif
-		testers.add(FILE_KEY_TYPEListRetainAllTester.class);
+		testers.add(FILE_KEY_TYPEListRetainAllTester.class);
-		testers.add(FILE_KEY_TYPEListSetTester.class);
+		testers.add(FILE_KEY_TYPEListSetTester.class);
-		testers.add(FILE_KEY_TYPEListSubListTester.class);
+		testers.add(FILE_KEY_TYPEListSubListTester.class);
-		testers.add(FILE_KEY_TYPEListToArrayTester.class);
+		testers.add(FILE_KEY_TYPEListToArrayTester.class);
-		return testers;
+		return testers;
-	}
+	}
-
+
-	@Override
+	@Override
-	public TestSuite createTestSuite() {
+	public TestSuite createTestSuite() {
-#ignore
+#ignore
-		withFeatures(KNOWN_ORDER);
+		withFeatures(KNOWN_ORDER);
-#endignore
+#endignore
-		return super.createTestSuite();
+		return super.createTestSuite();
-	}
+	}
-
+
-	@Override
+	@Override
-	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
-		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
+		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
-#ignore
+#ignore
-		if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
+		if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
-#endignore
+#endignore
-			derivedSuites.add(ListTestSuiteBuilder.using(new ReserializedListGenerator<CLASS_TYPE>(parentBuilder.getSubjectGenerator()))
+			derivedSuites.add(ListTestSuiteBuilder.using(new ReserializedListGenerator<CLASS_TYPE>(parentBuilder.getSubjectGenerator()))
-							.named(getName() + " reserialized")
+							.named(getName() + " reserialized")
-							.withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
+							.withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
-							.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+							.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
-							.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+							.withTearDown(parentBuilder.getTearDown()).createTestSuite());
-		}
+		}
-#ignore
+#ignore
-		if(!parentBuilder.getFeatures().contains(CollectionFeature.SUBSET_VIEW)) {
+		if(!parentBuilder.getFeatures().contains(CollectionFeature.SUBSET_VIEW)) {
-#endignore
+#endignore
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-			if(prefixes != null) {
+			if(prefixes != null) {
-				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), prefixes, null))
+				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), prefixes, null))
-						.named(getName() + " subSet_prefix")
+						.named(getName() + " subSet_prefix")
-						.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
+						.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
-						.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+						.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
-						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
-			}
+			}
-			if(suffixes != null) {
+			if(suffixes != null) {
-				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), null, suffixes))
+				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), null, suffixes))
-					.named(getName() + " subSet_suffixes")
+					.named(getName() + " subSet_suffixes")
-					.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
+					.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
-					.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+					.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
-					.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+					.withTearDown(parentBuilder.getTearDown()).createTestSuite());
-			}
+			}
-			if(prefixes != null && suffixes != null) {
+			if(prefixes != null && suffixes != null) {
-				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), prefixes, suffixes))
+				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), prefixes, suffixes))
-						.named(getName() + " subSet")
+						.named(getName() + " subSet")
-						.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
+						.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
-						.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+						.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
-						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
-			}
+			}
-#endif
+#endif
-		}
+		}
-		return derivedSuites;
+		return derivedSuites;
-	}
+	}
-	
+	
-	static class SubListListGenerator KEY_GENERIC_TYPE implements TEST_LIST_GENERATOR KEY_GENERIC_TYPE {
+	static class SubListListGenerator KEY_GENERIC_TYPE implements TEST_LIST_GENERATOR KEY_GENERIC_TYPE {
-		TEST_LIST_GENERATOR KEY_GENERIC_TYPE generator;
+		TEST_LIST_GENERATOR KEY_GENERIC_TYPE generator;
-		KEY_TYPE[] prefix;
+		KEY_TYPE[] prefix;
-		KEY_TYPE[] suffix;
+		KEY_TYPE[] suffix;
-		
+		
-		public SubListListGenerator(OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE> gen, KEY_TYPE[] prefix, KEY_TYPE[] suffix) {
+		public SubListListGenerator(OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE> gen, KEY_TYPE[] prefix, KEY_TYPE[] suffix) {
-			generator = (TEST_LIST_GENERATOR KEY_GENERIC_TYPE)gen.getInnerGenerator();
+			generator = (TEST_LIST_GENERATOR KEY_GENERIC_TYPE)gen.getInnerGenerator();
-			this.prefix = prefix;
+			this.prefix = prefix;
-			this.suffix = suffix;
+			this.suffix = suffix;
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public SampleElements<CLASS_TYPE> samples() {
+		public SampleElements<CLASS_TYPE> samples() {
-			return generator.samples();
+			return generator.samples();
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public CLASS_TYPE[] createArray(int length) {
+		public CLASS_TYPE[] createArray(int length) {
-			return generator.createArray(length);
+			return generator.createArray(length);
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
-			return generator.order(insertionOrder);
+			return generator.order(insertionOrder);
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+		public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
-			return generator.getSamples();
+			return generator.getSamples();
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
-			return generator.order(insertionOrder);
+			return generator.order(insertionOrder);
-		}
+		}
-		
+		
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-		@Override
+		@Override
-		public LIST KEY_GENERIC_TYPE create(Object... elements) {
+		public LIST KEY_GENERIC_TYPE create(Object... elements) {
-			KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
+			KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
-			int i = 0;
+			int i = 0;
-			for (Object e : elements) {
+			for (Object e : elements) {
-				array[i++] = CLASS_TO_KEY(e);
+				array[i++] = CLASS_TO_KEY(e);
-			}
+			}
-			return create(array);
+			return create(array);
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public LIST KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+		public LIST KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
-			int length = getLength(prefix);
+			int length = getLength(prefix);
-			return generator.create(merge(elements)).subList(length, length+elements.length);
+			return generator.create(merge(elements)).subList(length, length+elements.length);
-		}
+		}
-		
+		
-#else
+#else
-		@Override
+		@Override
-		public LIST KEY_GENERIC_TYPE create(Object... elements) {
+		public LIST KEY_GENERIC_TYPE create(Object... elements) {
-			KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
+			KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
-			int i = 0;
+			int i = 0;
-			for (Object e : elements) {
+			for (Object e : elements) {
-				array[i++] = CLASS_TO_KEY(e);
+				array[i++] = CLASS_TO_KEY(e);
-			}
+			}
-			int length = getLength(prefix);
+			int length = getLength(prefix);
-			return generator.create(merge(array)).subList(length, length+elements.length);
+			return generator.create(merge(array)).subList(length, length+elements.length);
-		}
+		}
-		
+		
-#endif
+#endif
-		private int getLength(KEY_TYPE[] keys) {
+		private int getLength(KEY_TYPE[] keys) {
-			return keys == null ? 0 : keys.length;
+			return keys == null ? 0 : keys.length;
-		}
+		}
-		
+		
-		private KEY_TYPE[] merge(KEY_TYPE[] input) {
+		private KEY_TYPE[] merge(KEY_TYPE[] input) {
-			int prefixLength = getLength(prefix);
+			int prefixLength = getLength(prefix);
-			int suffixLength = getLength(suffix);
+			int suffixLength = getLength(suffix);
-			KEY_TYPE[] result = NEW_KEY_ARRAY(input.length+prefixLength+suffixLength);
+			KEY_TYPE[] result = NEW_KEY_ARRAY(input.length+prefixLength+suffixLength);
-			if(prefixLength != 0) System.arraycopy(prefix, 0, result, 0, prefixLength);
+			if(prefixLength != 0) System.arraycopy(prefix, 0, result, 0, prefixLength);
-			System.arraycopy(input, 0, result, prefixLength, input.length);
+			System.arraycopy(input, 0, result, prefixLength, input.length);
-			if(suffixLength != 0) System.arraycopy(suffix, 0, result, prefixLength+input.length, suffixLength);
+			if(suffixLength != 0) System.arraycopy(suffix, 0, result, prefixLength+input.length, suffixLength);
-			return result;
+			return result;
-		}
+		}
-	}
+	}
-	
+	
-	static class ReserializedListGenerator<E> implements TestListGenerator<E> {
+	static class ReserializedListGenerator<E> implements TestListGenerator<E> {
-		final OneSizeTestContainerGenerator<Collection<E>, E> gen;
+		final OneSizeTestContainerGenerator<Collection<E>, E> gen;
-
+
-		private ReserializedListGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
+		private ReserializedListGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
-			this.gen = gen;
+			this.gen = gen;
-		}
+		}
-
+
-		@Override
+		@Override
-		public SampleElements<E> samples() {
+		public SampleElements<E> samples() {
-			return gen.samples();
+			return gen.samples();
-		}
+		}
-
+
-		@Override
+		@Override
-		public List<E> create(Object... elements) {
+		public List<E> create(Object... elements) {
-			return (List<E>) SerializableTester.reserialize(gen.create(elements));
+			return (List<E>) SerializableTester.reserialize(gen.create(elements));
-		}
+		}
-
+
-		@Override
+		@Override
-		public E[] createArray(int length) {
+		public E[] createArray(int length) {
-			return gen.createArray(length);
+			return gen.createArray(length);
-		}
+		}
-
+
-		@Override
+		@Override
-		public Iterable<E> order(List<E> insertionOrder) {
+		public Iterable<E> order(List<E> insertionOrder) {
-			return gen.order(insertionOrder);
+			return gen.order(insertionOrder);
-		}
+		}
-	}
+	}
-	
+	
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-	private static Set<Feature<?>> computeSubListFeatures(Set<Feature<?>> features) {
+	private static Set<Feature<?>> computeSubListFeatures(Set<Feature<?>> features) {
-		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
+		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
-#ignore
+#ignore
-		derivedFeatures.add(CollectionFeature.SUBSET_VIEW);
+		derivedFeatures.add(CollectionFeature.SUBSET_VIEW);
-		derivedFeatures.remove(SpecialFeature.COPYING);
+		derivedFeatures.remove(SpecialFeature.COPYING);
-		derivedFeatures.remove(SpecialFeature.CHILDREN_COPY);
+		derivedFeatures.remove(SpecialFeature.CHILDREN_COPY);
-#endignore
+#endignore
-		return derivedFeatures;
+		return derivedFeatures;
-	}
+	}
-
+
-#endif
+#endif
-	private static Set<Feature<?>> computeReserializedCollectionFeatures(Set<Feature<?>> features) {
+	private static Set<Feature<?>> computeReserializedCollectionFeatures(Set<Feature<?>> features) {
-		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
+		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
-#ignore
+#ignore
-		derivedFeatures.remove(SERIALIZABLE);
+		derivedFeatures.remove(SERIALIZABLE);
-		derivedFeatures.remove(SERIALIZABLE_INCLUDING_VIEWS);
+		derivedFeatures.remove(SERIALIZABLE_INCLUDING_VIEWS);
-#endignore
+#endignore
-		return derivedFeatures;
+		return derivedFeatures;
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/NavigableSetTestSuiteBuilder.template

@@ -1,140 +1,140 @@
-package speiger.src.testers.PACKAGE.builder;
+package speiger.src.testers.PACKAGE.builder;
-
+
-#ignore
+#ignore
-import static com.google.common.collect.testing.features.CollectionFeature.DESCENDING_VIEW;
+import static com.google.common.collect.testing.features.CollectionFeature.DESCENDING_VIEW;
-import static com.google.common.collect.testing.features.CollectionFeature.SUBSET_VIEW;
+import static com.google.common.collect.testing.features.CollectionFeature.SUBSET_VIEW;
-#endignore
+#endignore
-
+
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Collection;
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
-import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.Helpers;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.SampleElements;
-import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.features.Feature;
-import com.google.common.collect.testing.testers.NavigableSetNavigationTester;
+import com.google.common.collect.testing.testers.NavigableSetNavigationTester;
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
-import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
-import speiger.src.collections.PACKAGE.utils.LISTS;
+import speiger.src.collections.PACKAGE.utils.LISTS;
-import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.impl.SUB_SORTED_SET_CLASS_GENERATOR.SUB_NAVIGABLE_SET_CLASS_GENERATOR;
+import speiger.src.testers.PACKAGE.impl.SUB_SORTED_SET_CLASS_GENERATOR.SUB_NAVIGABLE_SET_CLASS_GENERATOR;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPENavigableSetNavigationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPENavigableSetNavigationTester;
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-import speiger.src.testers.utils.SpecialFeature;
+import speiger.src.testers.utils.SpecialFeature;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE {
+public class NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE {
-	public static GENERIC_KEY_BRACES NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+	public static GENERIC_KEY_BRACES NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE generator) {
-		return (NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE) new NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+		return (NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE) new NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
-		testers.add(NavigableSetNavigationTester.class);
+		testers.add(NavigableSetNavigationTester.class);
-		testers.add(FILE_KEY_TYPENavigableSetNavigationTester.class);
+		testers.add(FILE_KEY_TYPENavigableSetNavigationTester.class);
-		return testers;
+		return testers;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
-		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
+		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
-
+
-#ignore
+#ignore
-		if (!parentBuilder.getFeatures().contains(SUBSET_VIEW)) {
+		if (!parentBuilder.getFeatures().contains(SUBSET_VIEW)) {
-#endignore
+#endignore
-			// Other combinations are inherited from SortedSetTestSuiteBuilder.
+			// Other combinations are inherited from SortedSetTestSuiteBuilder.
-			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
-			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
-			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
-			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
-			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
-		}
+		}
-#ignore
+#ignore
-		if (!parentBuilder.getFeatures().contains(DESCENDING_VIEW)) {
+		if (!parentBuilder.getFeatures().contains(DESCENDING_VIEW)) {
-#endignore
+#endignore
-			derivedSuites.add(createDescendingSuite(parentBuilder));
+			derivedSuites.add(createDescendingSuite(parentBuilder));
-		}
+		}
-		return derivedSuites;
+		return derivedSuites;
-	}
+	}
-
+
-	@Override
+	@Override
-	SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE newBuilderUsing(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
+	SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE newBuilderUsing(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
-	    return NAVIGABLE_SET_TEST_BUILDER.using(new SUB_NAVIGABLE_SET_CLASS_GENERATORBRACES(delegate, to, from));
+	    return NAVIGABLE_SET_TEST_BUILDER.using(new SUB_NAVIGABLE_SET_CLASS_GENERATORBRACES(delegate, to, from));
-	}
+	}
-	
+	
-	private TestSuite createDescendingSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+	private TestSuite createDescendingSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
-		TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE delegate = (TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
+		TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE delegate = (TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
-
+
-		List<Feature<?>> features = new ArrayList<>();
+		List<Feature<?>> features = new ArrayList<>();
-#ignore
+#ignore
-		features.add(DESCENDING_VIEW);
+		features.add(DESCENDING_VIEW);
-		features.addAll(parentBuilder.getFeatures());
+		features.addAll(parentBuilder.getFeatures());
-		features.remove(SpecialFeature.COPYING);
+		features.remove(SpecialFeature.COPYING);
-		features.remove(SpecialFeature.CHILDREN_COPY);
+		features.remove(SpecialFeature.CHILDREN_COPY);
-#endignore
+#endignore
-
+
-		return NAVIGABLE_SET_TEST_BUILDER.using(new TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE() {
+		return NAVIGABLE_SET_TEST_BUILDER.using(new TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE() {
-
+
-			@Override
+			@Override
-			public SampleElements<CLASS_TYPE> samples() {
+			public SampleElements<CLASS_TYPE> samples() {
-				return delegate.samples();
+				return delegate.samples();
-			}
+			}
-			
+			
-			@Override
+			@Override
-			public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+			public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
-				return delegate.getSamples();
+				return delegate.getSamples();
-			}
+			}
-
+
-			@Override
+			@Override
-			public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+			public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
-				LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+				LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
-				delegate.order(insertionOrder).forEach(list::add);
+				delegate.order(insertionOrder).forEach(list::add);
-				LISTS.reverse(list);
+				LISTS.reverse(list);
-				return list;
+				return list;
-			}
+			}
-
+
-			@Override
+			@Override
-			public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+			public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
-				LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+				LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
-				for(CLASS_TYPE entry : delegate.order(insertionOrder))
+				for(CLASS_TYPE entry : delegate.order(insertionOrder))
-				{
+				{
-					list.add(OBJ_TO_KEY(entry));
+					list.add(OBJ_TO_KEY(entry));
-				}
+				}
-				LISTS.reverse(list);
+				LISTS.reverse(list);
-				return list;
+				return list;
-			}
+			}
-			@Override
+			@Override
-			public KEY_TYPE belowSamplesLesser() { return delegate.aboveSamplesGreater(); }
+			public KEY_TYPE belowSamplesLesser() { return delegate.aboveSamplesGreater(); }
-			@Override
+			@Override
-			public KEY_TYPE belowSamplesGreater() { return delegate.aboveSamplesLesser(); }
+			public KEY_TYPE belowSamplesGreater() { return delegate.aboveSamplesLesser(); }
-			@Override
+			@Override
-			public KEY_TYPE aboveSamplesLesser() { return delegate.belowSamplesGreater(); }
+			public KEY_TYPE aboveSamplesLesser() { return delegate.belowSamplesGreater(); }
-			@Override
+			@Override
-			public KEY_TYPE aboveSamplesGreater() { return delegate.belowSamplesLesser(); }
+			public KEY_TYPE aboveSamplesGreater() { return delegate.belowSamplesLesser(); }
-			
+			
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-			@Override
+			@Override
-			public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+			public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
-				return delegate.create(elements).descendingSet();
+				return delegate.create(elements).descendingSet();
-			}
+			}
-
+
-#endif
+#endif
-			@Override
+			@Override
-			public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
+			public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
-				return delegate.create(elements).descendingSet();
+				return delegate.create(elements).descendingSet();
-			}
+			}
-		}).named(parentBuilder.getName() + " descending").withFeatures(features)
+		}).named(parentBuilder.getName() + " descending").withFeatures(features)
-				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
+				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/OrderedSetTestSuiteBuilder.template

@@ -1,38 +1,38 @@
-package speiger.src.testers.PACKAGE.builder;
+package speiger.src.testers.PACKAGE.builder;
-
+
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.Helpers;
-import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionFeature;
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetMoveTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetMoveTester;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetIterationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetIterationTester;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetNavigationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetNavigationTester;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER KEY_GENERIC_TYPE {
+public class ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER KEY_GENERIC_TYPE {
-	public static GENERIC_KEY_BRACES ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+	public static GENERIC_KEY_BRACES ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE generator) {
-		return (ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE) new ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+		return (ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE) new ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
-		testers.add(FILE_KEY_TYPEOrderedSetNavigationTester.class);
+		testers.add(FILE_KEY_TYPEOrderedSetNavigationTester.class);
-		testers.add(FILE_KEY_TYPEOrderedSetMoveTester.class);
+		testers.add(FILE_KEY_TYPEOrderedSetMoveTester.class);
-		testers.add(FILE_KEY_TYPEOrderedSetIterationTester.class);
+		testers.add(FILE_KEY_TYPEOrderedSetIterationTester.class);
-		return testers;
+		return testers;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public TestSuite createTestSuite() {
+	public TestSuite createTestSuite() {
-#ignore
+#ignore
-		withFeatures(CollectionFeature.KNOWN_ORDER);
+		withFeatures(CollectionFeature.KNOWN_ORDER);
-#endignore
+#endignore
-		return super.createTestSuite();
+		return super.createTestSuite();
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/QueueTestSuiteBuilder.template

@@ -1,60 +1,60 @@
-package speiger.src.testers.PACKAGE.builder;
+package speiger.src.testers.PACKAGE.builder;
-
+
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.PerCollectionSizeTestSuiteBuilder;
+import com.google.common.collect.testing.PerCollectionSizeTestSuiteBuilder;
-
+
-import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
+import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
-import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
-import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueDequeueTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueDequeueTester;
-import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueEnqueueTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueEnqueueTester;
-import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueFirstTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueFirstTester;
-import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueRemoveTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueRemoveTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueCountTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueCountTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueDistinctTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueDistinctTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueFilterTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueFilterTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueFindFirstTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueFindFirstTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueLimitTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueLimitTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueMapTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueMapTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueMatchesTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueMatchesTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueuePeekTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueuePeekTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueForEachTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueForEachTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueReduceTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueReduceTester;
-import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueSortedTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueSortedTester;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class QUEUE_TEST_BUILDER KEY_GENERIC_TYPE extends PerCollectionSizeTestSuiteBuilder<QUEUE_TEST_BUILDER KEY_GENERIC_TYPE, TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE, PRIORITY_QUEUE KEY_GENERIC_TYPE, CLASS_TYPE>
+public class QUEUE_TEST_BUILDER KEY_GENERIC_TYPE extends PerCollectionSizeTestSuiteBuilder<QUEUE_TEST_BUILDER KEY_GENERIC_TYPE, TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE, PRIORITY_QUEUE KEY_GENERIC_TYPE, CLASS_TYPE>
-{
+{
-	public static GENERIC_KEY_BRACES QUEUE_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE builder) {
+	public static GENERIC_KEY_BRACES QUEUE_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE builder) {
-		return new QUEUE_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(builder);
+		return new QUEUE_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(builder);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters()
+	protected List<Class<? extends AbstractTester>> getTesters()
-	{
+	{
-		List<Class<? extends AbstractTester>> testers = new ArrayList<>();
+		List<Class<? extends AbstractTester>> testers = new ArrayList<>();
-		testers.add(FILE_KEY_TYPEQueueEnqueueTester.class);
+		testers.add(FILE_KEY_TYPEQueueEnqueueTester.class);
-		testers.add(FILE_KEY_TYPEQueueDequeueTester.class);
+		testers.add(FILE_KEY_TYPEQueueDequeueTester.class);
-		testers.add(FILE_KEY_TYPEQueueFirstTester.class);
+		testers.add(FILE_KEY_TYPEQueueFirstTester.class);
-		testers.add(FILE_KEY_TYPEQueueRemoveTester.class);
+		testers.add(FILE_KEY_TYPEQueueRemoveTester.class);
-		testers.add(FILE_KEY_TYPEQueueCountTester.class);
+		testers.add(FILE_KEY_TYPEQueueCountTester.class);
-		testers.add(FILE_KEY_TYPEQueueCountTester.class);
+		testers.add(FILE_KEY_TYPEQueueCountTester.class);
-		testers.add(FILE_KEY_TYPEQueueDequeueTester.class);
+		testers.add(FILE_KEY_TYPEQueueDequeueTester.class);
-		testers.add(FILE_KEY_TYPEQueueDistinctTester.class);
+		testers.add(FILE_KEY_TYPEQueueDistinctTester.class);
-		testers.add(FILE_KEY_TYPEQueueFilterTester.class);
+		testers.add(FILE_KEY_TYPEQueueFilterTester.class);
-		testers.add(FILE_KEY_TYPEQueueFindFirstTester.class);
+		testers.add(FILE_KEY_TYPEQueueFindFirstTester.class);
-		testers.add(FILE_KEY_TYPEQueueFirstTester.class);
+		testers.add(FILE_KEY_TYPEQueueFirstTester.class);
-		testers.add(FILE_KEY_TYPEQueueLimitTester.class);
+		testers.add(FILE_KEY_TYPEQueueLimitTester.class);
-		testers.add(FILE_KEY_TYPEQueueMapTester.class);
+		testers.add(FILE_KEY_TYPEQueueMapTester.class);
-		testers.add(FILE_KEY_TYPEQueueMatchesTester.class);
+		testers.add(FILE_KEY_TYPEQueueMatchesTester.class);
-		testers.add(FILE_KEY_TYPEQueuePeekTester.class);
+		testers.add(FILE_KEY_TYPEQueuePeekTester.class);
-		testers.add(FILE_KEY_TYPEQueueForEachTester.class);
+		testers.add(FILE_KEY_TYPEQueueForEachTester.class);
-		testers.add(FILE_KEY_TYPEQueueReduceTester.class);
+		testers.add(FILE_KEY_TYPEQueueReduceTester.class);
-		testers.add(FILE_KEY_TYPEQueueSortedTester.class);
+		testers.add(FILE_KEY_TYPEQueueSortedTester.class);
-		return testers;
+		return testers;
-	}
+	}
-	
+	
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/SetTestSuiteBuilder.template

@@ -1,116 +1,116 @@
-package speiger.src.testers.PACKAGE.builder;
+package speiger.src.testers.PACKAGE.builder;
-
+
-#ignore
+#ignore
-import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE;
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE;
-import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS;
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS;
-#endignore
+#endignore
-
+
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Collection;
-import java.util.HashSet;
+import java.util.HashSet;
-import java.util.List;
+import java.util.List;
-import java.util.Set;
+import java.util.Set;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
-import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.Helpers;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.SampleElements;
-import com.google.common.collect.testing.SetTestSuiteBuilder;
+import com.google.common.collect.testing.SetTestSuiteBuilder;
-import com.google.common.collect.testing.TestSetGenerator;
+import com.google.common.collect.testing.TestSetGenerator;
-import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.features.Feature;
-import com.google.common.collect.testing.testers.CollectionSerializationEqualTester;
+import com.google.common.collect.testing.testers.CollectionSerializationEqualTester;
-import com.google.common.collect.testing.testers.SetAddAllTester;
+import com.google.common.collect.testing.testers.SetAddAllTester;
-import com.google.common.collect.testing.testers.SetAddTester;
+import com.google.common.collect.testing.testers.SetAddTester;
-import com.google.common.collect.testing.testers.SetCreationTester;
+import com.google.common.collect.testing.testers.SetCreationTester;
-import com.google.common.collect.testing.testers.SetEqualsTester;
+import com.google.common.collect.testing.testers.SetEqualsTester;
-import com.google.common.collect.testing.testers.SetHashCodeTester;
+import com.google.common.collect.testing.testers.SetHashCodeTester;
-import com.google.common.collect.testing.testers.SetRemoveTester;
+import com.google.common.collect.testing.testers.SetRemoveTester;
-import com.google.common.testing.SerializableTester;
+import com.google.common.testing.SerializableTester;
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetAddAllTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetAddAllTester;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetAddTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetAddTester;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetCreationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetCreationTester;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetEqualsTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetEqualsTester;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetRemoveTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetRemoveTester;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class SET_TEST_BUILDER KEY_GENERIC_TYPE extends COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE {
+public class SET_TEST_BUILDER KEY_GENERIC_TYPE extends COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE {
-	public static GENERIC_KEY_BRACES SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+	public static GENERIC_KEY_BRACES SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
-		return (SET_TEST_BUILDER KEY_GENERIC_TYPE) new SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+		return (SET_TEST_BUILDER KEY_GENERIC_TYPE) new SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
-	    testers.add(CollectionSerializationEqualTester.class);
+	    testers.add(CollectionSerializationEqualTester.class);
-	    testers.add(SetAddAllTester.class);
+	    testers.add(SetAddAllTester.class);
-	    testers.add(SetAddTester.class);
+	    testers.add(SetAddTester.class);
-	    testers.add(SetCreationTester.class);
+	    testers.add(SetCreationTester.class);
-	    testers.add(SetHashCodeTester.class);
+	    testers.add(SetHashCodeTester.class);
-	    testers.add(SetEqualsTester.class);
+	    testers.add(SetEqualsTester.class);
-	    testers.add(SetRemoveTester.class);
+	    testers.add(SetRemoveTester.class);
-	    
+	    
-		testers.add(FILE_KEY_TYPESetAddAllTester.class);
+		testers.add(FILE_KEY_TYPESetAddAllTester.class);
-		testers.add(FILE_KEY_TYPESetAddTester.class);
+		testers.add(FILE_KEY_TYPESetAddTester.class);
-		testers.add(FILE_KEY_TYPESetCreationTester.class);
+		testers.add(FILE_KEY_TYPESetCreationTester.class);
-		testers.add(FILE_KEY_TYPESetEqualsTester.class);
+		testers.add(FILE_KEY_TYPESetEqualsTester.class);
-		testers.add(FILE_KEY_TYPESetRemoveTester.class);
+		testers.add(FILE_KEY_TYPESetRemoveTester.class);
-		return testers;
+		return testers;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	protected List<TestSuite> createDerivedSuites(
+	protected List<TestSuite> createDerivedSuites(
-			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
-		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
+		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
-
+
-		if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
+		if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
-			derivedSuites.add(SetTestSuiteBuilder.using(new ReserializedSetGenerator<CLASS_TYPE>(parentBuilder.getSubjectGenerator()))
+			derivedSuites.add(SetTestSuiteBuilder.using(new ReserializedSetGenerator<CLASS_TYPE>(parentBuilder.getSubjectGenerator()))
-							.named(getName() + " reserialized")
+							.named(getName() + " reserialized")
-							.withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
+							.withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
-							.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+							.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
-							.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+							.withTearDown(parentBuilder.getTearDown()).createTestSuite());
-		}
+		}
-		return derivedSuites;
+		return derivedSuites;
-	}
+	}
-
+
-	static class ReserializedSetGenerator<E> implements TestSetGenerator<E> {
+	static class ReserializedSetGenerator<E> implements TestSetGenerator<E> {
-		final OneSizeTestContainerGenerator<Collection<E>, E> gen;
+		final OneSizeTestContainerGenerator<Collection<E>, E> gen;
-
+
-		private ReserializedSetGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
+		private ReserializedSetGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
-			this.gen = gen;
+			this.gen = gen;
-		}
+		}
-
+
-		@Override
+		@Override
-		public SampleElements<E> samples() {
+		public SampleElements<E> samples() {
-			return gen.samples();
+			return gen.samples();
-		}
+		}
-
+
-		@Override
+		@Override
-		public Set<E> create(Object... elements) {
+		public Set<E> create(Object... elements) {
-			return (Set<E>) SerializableTester.reserialize(gen.create(elements));
+			return (Set<E>) SerializableTester.reserialize(gen.create(elements));
-		}
+		}
-
+
-		@Override
+		@Override
-		public E[] createArray(int length) {
+		public E[] createArray(int length) {
-			return gen.createArray(length);
+			return gen.createArray(length);
-		}
+		}
-
+
-		@Override
+		@Override
-		public Iterable<E> order(List<E> insertionOrder) {
+		public Iterable<E> order(List<E> insertionOrder) {
-			return gen.order(insertionOrder);
+			return gen.order(insertionOrder);
-		}
+		}
-	}
+	}
-
+
-	private static Set<Feature<?>> computeReserializedCollectionFeatures(Set<Feature<?>> features) {
+	private static Set<Feature<?>> computeReserializedCollectionFeatures(Set<Feature<?>> features) {
-		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
+		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
-#ignore
+#ignore
-		derivedFeatures.remove(SERIALIZABLE);
+		derivedFeatures.remove(SERIALIZABLE);
-		derivedFeatures.remove(SERIALIZABLE_INCLUDING_VIEWS);
+		derivedFeatures.remove(SERIALIZABLE_INCLUDING_VIEWS);
-#endignore
+#endignore
-		return derivedFeatures;
+		return derivedFeatures;
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/SortedSetTestSuiteBuilder.template

@@ -1,88 +1,88 @@
-package speiger.src.testers.PACKAGE.builder;
+package speiger.src.testers.PACKAGE.builder;
-
+
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Collection;
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
-import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.Helpers;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionFeature;
-import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.features.Feature;
-import com.google.common.collect.testing.testers.SortedSetNavigationTester;
+import com.google.common.collect.testing.testers.SortedSetNavigationTester;
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.impl.SUB_SORTED_SET_CLASS_GENERATOR;
+import speiger.src.testers.PACKAGE.impl.SUB_SORTED_SET_CLASS_GENERATOR;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESortedSetIterationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESortedSetIterationTester;
-import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESortedSetNaviationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESortedSetNaviationTester;
-import speiger.src.testers.utils.SpecialFeature;
+import speiger.src.testers.utils.SpecialFeature;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER KEY_GENERIC_TYPE {
+public class SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER KEY_GENERIC_TYPE {
-	public static GENERIC_KEY_BRACES SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+	public static GENERIC_KEY_BRACES SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE generator) {
-		return (SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE) new SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+		return (SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE) new SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
-		testers.add(SortedSetNavigationTester.class);
+		testers.add(SortedSetNavigationTester.class);
-		testers.add(FILE_KEY_TYPESortedSetIterationTester.class);
+		testers.add(FILE_KEY_TYPESortedSetIterationTester.class);
-		testers.add(FILE_KEY_TYPESortedSetNaviationTester.class);
+		testers.add(FILE_KEY_TYPESortedSetNaviationTester.class);
-		return testers;
+		return testers;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public TestSuite createTestSuite() {
+	public TestSuite createTestSuite() {
-		if (!getFeatures().contains(CollectionFeature.KNOWN_ORDER)) {
+		if (!getFeatures().contains(CollectionFeature.KNOWN_ORDER)) {
-			List<Feature<?>> features = Helpers.copyToList(getFeatures());
+			List<Feature<?>> features = Helpers.copyToList(getFeatures());
-#ignore
+#ignore
-			features.add(CollectionFeature.KNOWN_ORDER);
+			features.add(CollectionFeature.KNOWN_ORDER);
-#endignore
+#endignore
-			withFeatures(features);
+			withFeatures(features);
-		}
+		}
-		return super.createTestSuite();
+		return super.createTestSuite();
-	}
+	}
-
+
-	@Override
+	@Override
-	protected List<TestSuite> createDerivedSuites(
+	protected List<TestSuite> createDerivedSuites(
-			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
-		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
+		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
-
+
-#ignore
+#ignore
-		if (!parentBuilder.getFeatures().contains(CollectionFeature.SUBSET_VIEW)) {
+		if (!parentBuilder.getFeatures().contains(CollectionFeature.SUBSET_VIEW)) {
-#endignore
+#endignore
-			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE));
-			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.NO_BOUND));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.NO_BOUND));
-			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.EXCLUSIVE));
-		}
+		}
-
+
-		return derivedSuites;
+		return derivedSuites;
-	}
+	}
-
+
-	final TestSuite createSubsetSuite(
+	final TestSuite createSubsetSuite(
-			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder,
+			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder,
-			Bound from, Bound to) {
+			Bound from, Bound to) {
-		TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate = (TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
+		TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate = (TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
-
+
-		List<Feature<?>> features = new ArrayList<>(parentBuilder.getFeatures());
+		List<Feature<?>> features = new ArrayList<>(parentBuilder.getFeatures());
-#ignore
+#ignore
-		features.remove(CollectionFeature.ALLOWS_NULL_VALUES);
+		features.remove(CollectionFeature.ALLOWS_NULL_VALUES);
-		features.add(CollectionFeature.SUBSET_VIEW);
+		features.add(CollectionFeature.SUBSET_VIEW);
-		features.remove(SpecialFeature.COPYING);
+		features.remove(SpecialFeature.COPYING);
-		features.remove(SpecialFeature.CHILDREN_COPY);
+		features.remove(SpecialFeature.CHILDREN_COPY);
-#endignore
+#endignore
-
+
-		return newBuilderUsing(delegate, to, from).named(parentBuilder.getName() + " subSet " + from + "-" + to)
+		return newBuilderUsing(delegate, to, from).named(parentBuilder.getName() + " subSet " + from + "-" + to)
-				.withFeatures(features).suppressing(parentBuilder.getSuppressedTests())
+				.withFeatures(features).suppressing(parentBuilder.getSuppressedTests())
-				.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown()).createTestSuite();
+				.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown()).createTestSuite();
-	}
+	}
-
+
-	SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE newBuilderUsing(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
+	SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE newBuilderUsing(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
-		return using(new SUB_SORTED_SET_CLASS_GENERATORBRACES(delegate, to, from));
+		return using(new SUB_SORTED_SET_CLASS_GENERATORBRACES(delegate, to, from));
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/maps/MapTestSuiteBuilder.template

@@ -1,304 +1,318 @@
-package speiger.src.testers.PACKAGE.builder.maps;
+package speiger.src.testers.PACKAGE.builder.maps;
-
+
-import java.lang.reflect.Method;
+import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-import java.util.Set;
+import java.util.Set;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
-import com.google.common.collect.testing.MapTestSuiteBuilder;
+import com.google.common.collect.testing.MapTestSuiteBuilder;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionFeature;
-import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.features.Feature;
-import com.google.common.collect.testing.features.MapFeature;
+import com.google.common.collect.testing.features.MapFeature;
-import com.google.common.collect.testing.testers.CollectionIteratorTester;
+import com.google.common.collect.testing.testers.CollectionIteratorTester;
-#if VALUE_BOOLEAN
+#if VALUE_BOOLEAN
-import com.google.common.collect.testing.testers.CollectionRemoveTester;
+import com.google.common.collect.testing.testers.CollectionRemoveTester;
-import com.google.common.collect.testing.testers.CollectionRetainAllTester;
+import com.google.common.collect.testing.testers.CollectionRetainAllTester;
-#endif
+#endif
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.testers.VALUE_PACKAGE.builder.VALUE_COLLECTION_TEST_BUILDER;
+import speiger.src.testers.VALUE_PACKAGE.builder.VALUE_COLLECTION_TEST_BUILDER;
-import speiger.src.testers.VALUE_PACKAGE.generators.VALUE_TEST_COLLECTION_GENERATOR;
+import speiger.src.testers.VALUE_PACKAGE.generators.VALUE_TEST_COLLECTION_GENERATOR;
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
-import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
-#endif
+#endif
-import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
-import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
+import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
-#if TYPE_CHAR || TYPE_FLOAT || TYPE_DOUBLE
+#if TYPE_CHAR || TYPE_FLOAT || TYPE_DOUBLE
-import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionIteratorTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionIteratorTester;
-#if !SAME_TYPE && !VALUE_OBJECT
+#if !SAME_TYPE && !VALUE_OBJECT
-import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
-#endif
+#endif
-#else if TYPE_OBJECT && !VALUE_OBJECT
+#else if TYPE_OBJECT && !VALUE_OBJECT
-import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
-#endif
+#endif
-#if VALUE_PRIMITIVES
+#if VALUE_PRIMITIVES
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapAddToTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapAddToTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSubFromTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSubFromTester;
-#endif
+#endif
-#if VALUE_BOOLEAN
+#if VALUE_BOOLEAN
-#if !TYPE_CHAR && !TYPE_FLOAT && !TYPE_DOUBLE && !TYPE_OBJECT
+#if !TYPE_CHAR && !TYPE_FLOAT && !TYPE_DOUBLE && !TYPE_OBJECT
-import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
-#endif
+#endif
-import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionRemoveAllTester;
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionRemoveAllTester;
-import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionRetainAllTester;
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionRetainAllTester;
-#endif
+#endif
-
+
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapClearTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapClearTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfAbsentTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfAbsentTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfPresentTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfPresentTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapCopyTester;
+#if !VALUE_OBJECT
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfAbsentNonDefaultTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsKeyTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfPresentNonDefaultTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsValueTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeNonDefaultTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapEntrySetTester;
+#endif
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapEqualsTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapCopyTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapForEachTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetOrDefaultTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsKeyTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsValueTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapHashCodeTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapEntrySetTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapIsEmptyTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapEqualsTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapForEachTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeBulkTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetOrDefaultTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllArrayTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapHashCodeTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutIfAbsentTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapIsEmptyTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeBulkTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveOrDefaultTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllArrayTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceAllTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutIfAbsentTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceEntryTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSizeTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveOrDefaultTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSupplyIfAbsentTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapToStringTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceAllTester;
-import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceEntryTester;
-import speiger.src.testers.objects.generators.TestObjectSetGenerator;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceTester;
-import speiger.src.testers.objects.tests.collection.ObjectCollectionIteratorTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSizeTester;
-import speiger.src.testers.objects.tests.collection.ObjectCollectionRemoveAllTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSupplyIfAbsentTester;
-import speiger.src.testers.objects.tests.collection.ObjectCollectionRetainAllTester;
+#if !VALUE_OBJECT
-import speiger.src.testers.utils.SpecialFeature;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSupplyIfAbsentNonDefaultTester;
-import speiger.src.testers.utils.TestUtils;
+#endif
-
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapToStringTester;
-@SuppressWarnings("javadoc")
+import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder;
-public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder<CLASS_TYPE, CLASS_VALUE_TYPE> {
+import speiger.src.testers.objects.generators.TestObjectSetGenerator;
-	boolean shouldBlockKeys;
+import speiger.src.testers.objects.tests.collection.ObjectCollectionIteratorTester;
-	
+import speiger.src.testers.objects.tests.collection.ObjectCollectionRemoveAllTester;
-	public static GENERIC_KEY_VALUE_BRACES MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
+import speiger.src.testers.objects.tests.collection.ObjectCollectionRetainAllTester;
-		return (MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
+import speiger.src.testers.utils.SpecialFeature;
-	}
+import speiger.src.testers.utils.TestUtils;
-	
+
-	public MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE shouldBlockKeys(boolean value) {
+@SuppressWarnings("javadoc")
-		shouldBlockKeys = value;
+public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder<CLASS_TYPE, CLASS_VALUE_TYPE> {
-		return this;
+	boolean shouldBlockKeys;
-	}
+	
-	
+	public static GENERIC_KEY_VALUE_BRACES MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
-	@Override
+		return (MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
-	@SuppressWarnings("rawtypes")
+	}
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	
-		List<Class<? extends AbstractTester>> testers = new ArrayList<>();
+	public MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE shouldBlockKeys(boolean value) {
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapClearTester.class);
+		shouldBlockKeys = value;
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeTester.class);
+		return this;
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfAbsentTester.class);
+	}
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfPresentTester.class);
+	
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSupplyIfAbsentTester.class);
+	@Override
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapCopyTester.class);
+	@SuppressWarnings("rawtypes")
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester.class);
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsKeyTester.class);
+		List<Class<? extends AbstractTester>> testers = new ArrayList<>();
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsValueTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapClearTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapEntrySetTester.class);
+#if !VALUE_OBJECT
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapEqualsTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeNonDefaultTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapForEachTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfAbsentNonDefaultTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfPresentNonDefaultTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetOrDefaultTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSupplyIfAbsentNonDefaultTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapHashCodeTester.class);
+#endif
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapIsEmptyTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfAbsentTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeBulkTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfPresentTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSupplyIfAbsentTester.class);
-#if VALUE_PRIMITIVES
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapCopyTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapAddToTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSubFromTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsKeyTester.class);
-#endif
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsValueTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapEntrySetTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllArrayTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapEqualsTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutIfAbsentTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapForEachTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetOrDefaultTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveOrDefaultTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapHashCodeTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapIsEmptyTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceAllTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceEntryTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeBulkTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSizeTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapToStringTester.class);
+#if VALUE_PRIMITIVES
-		return testers;
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapAddToTester.class);
-	}
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSubFromTester.class);
-
+#endif
-	@Override
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllTester.class);
-	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllArrayTester.class);
-		List<TestSuite> derivedSuites = new ArrayList<>();
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutIfAbsentTester.class);
-		derivedSuites.add(createDerivedEntrySetSuite(
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveTester.class);
-				DERIVED_MAP_GENERATORS.entrySetGenerator(parentBuilder.getSubjectGenerator()))
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester.class);
-						.withFeatures(computeEntrySetFeatures(parentBuilder.getFeatures()))
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveOrDefaultTester.class);
-						.named(parentBuilder.getName() + " entrySet")
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceTester.class);
-						.suppressing(getEntrySetSuppressing(parentBuilder.getSuppressedTests())).suppressing(getSuppressing(1))
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceAllTester.class);
-						.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown())
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceEntryTester.class);
-						.createTestSuite());
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSizeTester.class);
-
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapToStringTester.class);
-		derivedSuites.add(createDerivedKeySetSuite(
+		return testers;
-				DERIVED_MAP_GENERATORS.keySetGenerator(parentBuilder.getSubjectGenerator()))
+	}
-						.withFeatures(computeKeySetFeatures(parentBuilder.getFeatures()))
+
-						.named(parentBuilder.getName() + " keys").suppressing(parentBuilder.getSuppressedTests()).suppressing(getSuppressing(0))
+	@Override
-						.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown())
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
-						.createTestSuite());
+		List<TestSuite> derivedSuites = new ArrayList<>();
-#if !TYPE_CHAR && !TYPE_OBJECT && !TYPE_FLOAT && !TYPE_DOUBLE || !VALUE_BOOLEAN
+		derivedSuites.add(createDerivedEntrySetSuite(
-		derivedSuites.add(createDerivedValueCollectionSuite(
+				DERIVED_MAP_GENERATORS.entrySetGenerator(parentBuilder.getSubjectGenerator()))
-				new DERIVED_MAP_GENERATORS.MapValueCollectionGeneratorKV_BRACES(parentBuilder.getSubjectGenerator()))
+						.withFeatures(computeEntrySetFeatures(parentBuilder.getFeatures()))
-						.named(parentBuilder.getName() + " values")
+						.named(parentBuilder.getName() + " entrySet")
-						.withFeatures(computeValuesCollectionFeatures(parentBuilder.getFeatures()))
+						.suppressing(getEntrySetSuppressing(parentBuilder.getSuppressedTests())).suppressing(getSuppressing(1))
-						.suppressing(parentBuilder.getSuppressedTests()).suppressing(getSuppressing(2)).withSetUp(parentBuilder.getSetUp())
+						.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown())
-						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+						.createTestSuite());
-#endif
+
-		return derivedSuites;
+		derivedSuites.add(createDerivedKeySetSuite(
-	}
+				DERIVED_MAP_GENERATORS.keySetGenerator(parentBuilder.getSubjectGenerator()))
-
+						.withFeatures(computeKeySetFeatures(parentBuilder.getFeatures()))
-	protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) {
+						.named(parentBuilder.getName() + " keys").suppressing(parentBuilder.getSuppressedTests()).suppressing(getSuppressing(0))
-		return ObjectSetTestSuiteBuilder.using(entrySetGenerator);
+						.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown())
-	}
+						.createTestSuite());
-	
+#if !TYPE_CHAR && !TYPE_OBJECT && !TYPE_FLOAT && !TYPE_DOUBLE || !VALUE_BOOLEAN
-	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+		derivedSuites.add(createDerivedValueCollectionSuite(
-		return SET_TEST_BUILDER.using(generator);
+				new DERIVED_MAP_GENERATORS.MapValueCollectionGeneratorKV_BRACES(parentBuilder.getSubjectGenerator()))
-	}
+						.named(parentBuilder.getName() + " values")
-	
+						.withFeatures(computeValuesCollectionFeatures(parentBuilder.getFeatures()))
-	protected VALUE_COLLECTION_TEST_BUILDER VALUE_GENERIC_TYPE createDerivedValueCollectionSuite(VALUE_TEST_COLLECTION_GENERATOR VALUE_GENERIC_TYPE generator) {
+						.suppressing(parentBuilder.getSuppressedTests()).suppressing(getSuppressing(2)).withSetUp(parentBuilder.getSetUp())
-		return VALUE_COLLECTION_TEST_BUILDER.using(generator);
+						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
-	}
+#endif
-	
+		return derivedSuites;
-	private Method[] getSuppressing(int type) {
+	}
-#if TYPE_CHAR || TYPE_OBJECT || TYPE_FLOAT || TYPE_DOUBLE
+
-		if(shouldBlockKeys) {
+	protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) {
-			switch(type) {
+		return ObjectSetTestSuiteBuilder.using(entrySetGenerator);
-				case 0: return TestUtils.getSurpession(FILE_KEY_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+	}
-				case 1: return TestUtils.getSurpession(ObjectCollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+	
-				case 2: {
+	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
-					List<Method> result = new ArrayList<>();
+		return SET_TEST_BUILDER.using(generator);
-					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+	}
-#if VALUE_BOOLEAN
+	
-					TestUtils.getSurpession(result, CollectionRemoveTester.class, "testRemove_present");
+	protected VALUE_COLLECTION_TEST_BUILDER VALUE_GENERIC_TYPE createDerivedValueCollectionSuite(VALUE_TEST_COLLECTION_GENERATOR VALUE_GENERIC_TYPE generator) {
-					TestUtils.getSurpession(result, CollectionRetainAllTester.class);
+		return VALUE_COLLECTION_TEST_BUILDER.using(generator);
-					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+	}
-					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
+	
-					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRetainAllTester.class);
+	private Method[] getSuppressing(int type) {
-#endif
+#if TYPE_CHAR || TYPE_OBJECT || TYPE_FLOAT || TYPE_DOUBLE
-					return result.toArray(new Method[result.size()]);
+		if(shouldBlockKeys) {
-				}
+			switch(type) {
-			}
+				case 0: return TestUtils.getSurpession(FILE_KEY_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
-		}
+				case 1: return TestUtils.getSurpession(ObjectCollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
-		return new Method[0];
+				case 2: {
-#else if VALUE_BOOLEAN
+					List<Method> result = new ArrayList<>();
-		if(type == 2) {
+					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
-			List<Method> result = new ArrayList<>();
+#if VALUE_BOOLEAN
-			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+					TestUtils.getSurpession(result, CollectionRemoveTester.class, "testRemove_present");
-#if VALUE_BOOLEAN
+					TestUtils.getSurpession(result, CollectionRetainAllTester.class);
-			TestUtils.getSurpession(result, CollectionRemoveTester.class, "testRemove_present");
+					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
-			TestUtils.getSurpession(result, CollectionRetainAllTester.class);
+					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
-			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRetainAllTester.class);
-			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
+#endif
-			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRetainAllTester.class);
+					return result.toArray(new Method[result.size()]);
-#endif
+				}
-			return result.toArray(new Method[result.size()]);
+			}
-		}
+		}
-		return new Method[0];
+		return new Method[0];
-#else
+#else if VALUE_BOOLEAN
-		return new Method[0];
+		if(type == 2) {
-#endif
+			List<Method> result = new ArrayList<>();
-	}
+			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
-	
+#if VALUE_BOOLEAN
-	private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> mapFeatures) {
+			TestUtils.getSurpession(result, CollectionRemoveTester.class, "testRemove_present");
-		Set<Feature<?>> entrySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
+			TestUtils.getSurpession(result, CollectionRetainAllTester.class);
-#ignore
+			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
-		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) {
+			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
-			entrySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRetainAllTester.class);
-		}
+#endif
-		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
+			return result.toArray(new Method[result.size()]);
-			entrySetFeatures.add(SpecialFeature.COPYING);
+		}
-		}
+		return new Method[0];
-		else {
+#else
-			entrySetFeatures.remove(SpecialFeature.COPYING);
+		return new Method[0];
-		}
+#endif
-		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) {
+	}
-			entrySetFeatures.add(SpecialFeature.MODIFIABLE);
+	
-		}
+	private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> mapFeatures) {
-		else {
+		Set<Feature<?>> entrySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
-			entrySetFeatures.remove(SpecialFeature.MODIFIABLE);
+#ignore
-		}
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) {
-		entrySetFeatures.add(SpecialFeature.MAP_ENTRY);
+			entrySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
-#endignore
+		}
-		return entrySetFeatures;
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
-	}
+			entrySetFeatures.add(SpecialFeature.COPYING);
-
+		}
-	private static Set<Feature<?>> computeKeySetFeatures(Set<Feature<?>> mapFeatures) {
+		else {
-		Set<Feature<?>> keySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
+			entrySetFeatures.remove(SpecialFeature.COPYING);
-#ignore
+		}
-		keySetFeatures.add(CollectionFeature.SUBSET_VIEW);
+		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) {
-		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) {
+			entrySetFeatures.add(SpecialFeature.MODIFIABLE);
-			keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
+		}
-		} else if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) {
+		else {
-			keySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+			entrySetFeatures.remove(SpecialFeature.MODIFIABLE);
-		}
+		}
-		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
+		entrySetFeatures.add(SpecialFeature.MAP_ENTRY);
-			keySetFeatures.add(SpecialFeature.COPYING);
+#endignore
-		}
+		return entrySetFeatures;
-		else {
+	}
-			keySetFeatures.remove(SpecialFeature.COPYING);
+
-		}
+	private static Set<Feature<?>> computeKeySetFeatures(Set<Feature<?>> mapFeatures) {
-		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) {
+		Set<Feature<?>> keySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
-			keySetFeatures.add(SpecialFeature.MODIFIABLE);
+#ignore
-		}
+		keySetFeatures.add(CollectionFeature.SUBSET_VIEW);
-		else {
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) {
-			keySetFeatures.remove(SpecialFeature.MODIFIABLE);
+			keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
-		}
+		} else if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) {
-#endignore
+			keySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
-		return keySetFeatures;
+		}
-	}
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
-
+			keySetFeatures.add(SpecialFeature.COPYING);
-#if !TYPE_CHAR && !TYPE_OBJECT && !TYPE_FLOAT && !TYPE_DOUBLE || !VALUE_BOOLEAN
+		}
-	private static Set<Feature<?>> computeValuesCollectionFeatures(Set<Feature<?>> mapFeatures) {
+		else {
-		Set<Feature<?>> valuesCollectionFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
+			keySetFeatures.remove(SpecialFeature.COPYING);
-#ignore
+		}
-		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) {
+		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) {
-			valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+			keySetFeatures.add(SpecialFeature.MODIFIABLE);
-		}
+		}
-		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) {
+		else {
-			valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
+			keySetFeatures.remove(SpecialFeature.MODIFIABLE);
-		}
+		}
-		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
+#endignore
-			valuesCollectionFeatures.add(SpecialFeature.COPYING);
+		return keySetFeatures;
-		}
+	}
-		else {
+
-			valuesCollectionFeatures.remove(SpecialFeature.COPYING);
+#if !TYPE_CHAR && !TYPE_OBJECT && !TYPE_FLOAT && !TYPE_DOUBLE || !VALUE_BOOLEAN
-		}
+	private static Set<Feature<?>> computeValuesCollectionFeatures(Set<Feature<?>> mapFeatures) {
-#endignore
+		Set<Feature<?>> valuesCollectionFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
-		return valuesCollectionFeatures;
+#ignore
-	}
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) {
-	
+			valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
-#endif
+		}
-	private static Set<Method> getEntrySetSuppressing(Set<Method> suppressing) {
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) {
-		TestUtils.getSurpession(suppressing, CollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+			valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
-		TestUtils.getSurpession(suppressing, ObjectCollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+		}
-		TestUtils.getSurpession(suppressing, ObjectCollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
-		TestUtils.getSurpession(suppressing, ObjectCollectionRetainAllTester.class, "testRetainAllExtra_disjointPreviouslyNonEmpty", "testRetainAllExtra_containsDuplicatesSizeSeveral", "testRetainAllExtra_subset", "testRetainAllExtra_partialOverlap");
+			valuesCollectionFeatures.add(SpecialFeature.COPYING);
-#if TYPE_DOUBLE || TYPE_FLOAT
+		}
-		TestUtils.getSurpession(suppressing, CollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+		else {
-		TestUtils.getSurpession(suppressing, ObjectCollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+			valuesCollectionFeatures.remove(SpecialFeature.COPYING);
-#endif
+		}
-		return suppressing;
+#endignore
-	}
+		return valuesCollectionFeatures;
+	}
+	
+#endif
+	private static Set<Method> getEntrySetSuppressing(Set<Method> suppressing) {
+		TestUtils.getSurpession(suppressing, CollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+		TestUtils.getSurpession(suppressing, ObjectCollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+		TestUtils.getSurpession(suppressing, ObjectCollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
+		TestUtils.getSurpession(suppressing, ObjectCollectionRetainAllTester.class, "testRetainAllExtra_disjointPreviouslyNonEmpty", "testRetainAllExtra_containsDuplicatesSizeSeveral", "testRetainAllExtra_subset", "testRetainAllExtra_partialOverlap");
+#if TYPE_DOUBLE || TYPE_FLOAT
+		TestUtils.getSurpession(suppressing, CollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+		TestUtils.getSurpession(suppressing, ObjectCollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+#endif
+		return suppressing;
+	}
 }

src/builder/resources/speiger/assets/testers/templates/builder/maps/NavigableMapTestSuiteBuilder.template

@@ -1,79 +1,79 @@
-package speiger.src.testers.PACKAGE.builder.maps;
+package speiger.src.testers.PACKAGE.builder.maps;
-
+
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.features.Feature;
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.testers.PACKAGE.builder.NAVIGABLE_SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.builder.NAVIGABLE_SET_TEST_BUILDER;
-import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
-import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
+import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPENavigableMapNavigationTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPENavigableMapNavigationTester;
-import speiger.src.testers.utils.SpecialFeature;
+import speiger.src.testers.utils.SpecialFeature;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE
+public class NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE
-{
+{
-	public static GENERIC_KEY_VALUE_BRACES NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
+	public static GENERIC_KEY_VALUE_BRACES NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
-		return (NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE)new NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
+		return (NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE)new NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
-	}
+	}
-
+
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> testers = super.getTesters();
+		List<Class<? extends AbstractTester>> testers = super.getTesters();
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPENavigableMapNavigationTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPENavigableMapNavigationTester.class);
-		return testers;
+		return testers;
-	}
+	}
-
+
-	@Override
+	@Override
-	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
-		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
+		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
-#ignore
+#ignore
-		if (!parentBuilder.getFeatures().contains(SpecialFeature.DESCENDING)) {
+		if (!parentBuilder.getFeatures().contains(SpecialFeature.DESCENDING)) {
-			derivedSuites.add(createDescendingSuite(parentBuilder));
+			derivedSuites.add(createDescendingSuite(parentBuilder));
-		}
+		}
-		if (!parentBuilder.getFeatures().contains(SpecialFeature.SUBMAP)) {
+		if (!parentBuilder.getFeatures().contains(SpecialFeature.SUBMAP)) {
-			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
-			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
-			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
-			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
-			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
-		}
+		}
-#endignore
+#endignore
-		return derivedSuites;
+		return derivedSuites;
-	}
+	}
-
+
-	@Override
+	@Override
-	NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE newBuilderUsing(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate, Bound to, Bound from) {
+	NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE newBuilderUsing(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate, Bound to, Bound from) {
-		return NAVIGABLE_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.NavigableMapGeneratorKV_BRACES(delegate, to, from));
+		return NAVIGABLE_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.NavigableMapGeneratorKV_BRACES(delegate, to, from));
-	}
+	}
-
+
-	private TestSuite createDescendingSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
+	private TestSuite createDescendingSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
-		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
+		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
-
+
-		List<Feature<?>> features = new ArrayList<>();
+		List<Feature<?>> features = new ArrayList<>();
-#ignore
+#ignore
-		features.add(SpecialFeature.DESCENDING);
+		features.add(SpecialFeature.DESCENDING);
-		features.addAll(parentBuilder.getFeatures());
+		features.addAll(parentBuilder.getFeatures());
-		features.remove(SpecialFeature.COPYING);
+		features.remove(SpecialFeature.COPYING);
-		features.remove(SpecialFeature.CHILDREN_COPY);
+		features.remove(SpecialFeature.CHILDREN_COPY);
-#endignore
+#endignore
-		return NAVIGABLE_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.DescendingTestMapGeneratorKV_BRACES(delegate))
+		return NAVIGABLE_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.DescendingTestMapGeneratorKV_BRACES(delegate))
-				.named(parentBuilder.getName() + " descending").withFeatures(features)
+				.named(parentBuilder.getName() + " descending").withFeatures(features)
-				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
+				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
-	}
+	}
-
+
-	@Override
+	@Override
-	protected NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE keySetGenerator) {
+	protected NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE keySetGenerator) {
-		return NAVIGABLE_SET_TEST_BUILDER.using((TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE) keySetGenerator);
+		return NAVIGABLE_SET_TEST_BUILDER.using((TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE) keySetGenerator);
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template

@@ -1,55 +1,55 @@
-package speiger.src.testers.PACKAGE.builder.maps;
+package speiger.src.testers.PACKAGE.builder.maps;
-
+
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionFeature;
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.testers.PACKAGE.builder.ORDERED_SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.builder.ORDERED_SET_TEST_BUILDER;
-import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
-import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester;
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder;
+import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder;
-import speiger.src.testers.objects.generators.TestObjectSetGenerator;
+import speiger.src.testers.objects.generators.TestObjectSetGenerator;
-import speiger.src.testers.objects.builder.ObjectOrderedSetTestSuiteBuilder;
+import speiger.src.testers.objects.builder.ObjectOrderedSetTestSuiteBuilder;
-import speiger.src.testers.objects.generators.TestObjectOrderedSetGenerator;
+import speiger.src.testers.objects.generators.TestObjectOrderedSetGenerator;
-#endif
+#endif
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE
+public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE
-{
+{
-	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
+	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
-		return (ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
+		return (ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> testers = super.getTesters();
+		List<Class<? extends AbstractTester>> testers = super.getTesters();
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester.class);
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester.class);
-		return testers;
+		return testers;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public TestSuite createTestSuite() {
+	public TestSuite createTestSuite() {
-#ignore
+#ignore
-		withFeatures(CollectionFeature.KNOWN_ORDER);
+		withFeatures(CollectionFeature.KNOWN_ORDER);
-#endignore
+#endignore
-		return super.createTestSuite();
+		return super.createTestSuite();
-	}
+	}
-	
+	
-	protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) {
+	protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) {
-		return ObjectOrderedSetTestSuiteBuilder.using((TestObjectOrderedSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySetGenerator);
+		return ObjectOrderedSetTestSuiteBuilder.using((TestObjectOrderedSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySetGenerator);
-	}
+	}
-	
+	
-	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
-		return ORDERED_SET_TEST_BUILDER.using((TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE)generator);
+		return ORDERED_SET_TEST_BUILDER.using((TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE)generator);
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/builder/maps/SortedMapTestSuiteBuilder.template

@@ -1,90 +1,90 @@
-package speiger.src.testers.PACKAGE.builder.maps;
+package speiger.src.testers.PACKAGE.builder.maps;
-
+
-#ignore
+#ignore
-import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
+import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
-#endignore
+#endignore
-
+
-import java.util.ArrayList;
+import java.util.ArrayList;
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
-import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
-import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.Helpers;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.features.Feature;
-
+
-import junit.framework.TestSuite;
+import junit.framework.TestSuite;
-import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
-import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
+import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
-import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPESortedMapNavigationTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPESortedMapNavigationTester;
-import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
-import speiger.src.testers.PACKAGE.builder.SORTED_SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.builder.SORTED_SET_TEST_BUILDER;
-import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
-import speiger.src.testers.utils.SpecialFeature;
+import speiger.src.testers.utils.SpecialFeature;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE {
+public class SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE {
-	public static GENERIC_KEY_VALUE_BRACES SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
+	public static GENERIC_KEY_VALUE_BRACES SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
-		return (SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
+		return (SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
-	}
+	}
-
+
-	@Override
+	@Override
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings("rawtypes")
-	protected List<Class<? extends AbstractTester>> getTesters() {
+	protected List<Class<? extends AbstractTester>> getTesters() {
-		List<Class<? extends AbstractTester>> testers = super.getTesters();
+		List<Class<? extends AbstractTester>> testers = super.getTesters();
-		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPESortedMapNavigationTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPESortedMapNavigationTester.class);
-		return testers;
+		return testers;
-	}
+	}
-
+
-	@Override
+	@Override
-	public TestSuite createTestSuite() {
+	public TestSuite createTestSuite() {
-#ignore
+#ignore
-		if (!getFeatures().contains(KNOWN_ORDER)) {
+		if (!getFeatures().contains(KNOWN_ORDER)) {
-			List<Feature<?>> features = Helpers.copyToList(getFeatures());
+			List<Feature<?>> features = Helpers.copyToList(getFeatures());
-			features.add(KNOWN_ORDER);
+			features.add(KNOWN_ORDER);
-			withFeatures(features);
+			withFeatures(features);
-		}
+		}
-#endignore
+#endignore
-		return super.createTestSuite();
+		return super.createTestSuite();
-	}
+	}
-
+
-	@Override
+	@Override
-	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
-		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
+		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
-#ignore
+#ignore
-		if (!parentBuilder.getFeatures().contains(SpecialFeature.SUBMAP)) {
+		if (!parentBuilder.getFeatures().contains(SpecialFeature.SUBMAP)) {
-			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE));
-			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.NO_BOUND));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.NO_BOUND));
-			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.EXCLUSIVE));
-		}
+		}
-#endignore
+#endignore
-		return derivedSuites;
+		return derivedSuites;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE keySetGenerator) {
+	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE keySetGenerator) {
-		return keySetGenerator instanceof TEST_SORTED_SET_GENERATOR ? SORTED_SET_TEST_BUILDER.using((TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE) keySetGenerator) : SET_TEST_BUILDER.using(keySetGenerator);
+		return keySetGenerator instanceof TEST_SORTED_SET_GENERATOR ? SORTED_SET_TEST_BUILDER.using((TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE) keySetGenerator) : SET_TEST_BUILDER.using(keySetGenerator);
-	}
+	}
-
+
-	TestSuite createSubmapSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder, Bound from, Bound to) {
+	TestSuite createSubmapSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder, Bound from, Bound to) {
-		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
+		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
-		List<Feature<?>> features = new ArrayList<>();
+		List<Feature<?>> features = new ArrayList<>();
-#ignore
+#ignore
-		features.add(SpecialFeature.SUBMAP);
+		features.add(SpecialFeature.SUBMAP);
-		features.addAll(parentBuilder.getFeatures());
+		features.addAll(parentBuilder.getFeatures());
-		features.remove(SpecialFeature.COPYING);
+		features.remove(SpecialFeature.COPYING);
-		features.remove(SpecialFeature.CHILDREN_COPY);
+		features.remove(SpecialFeature.CHILDREN_COPY);
-#endignore
+#endignore
-
+
-		return newBuilderUsing(delegate, to, from).named(parentBuilder.getName() + " subMap " + from + "-" + to)
+		return newBuilderUsing(delegate, to, from).named(parentBuilder.getName() + " subMap " + from + "-" + to)
-				.withFeatures(features).suppressing(parentBuilder.getSuppressedTests())
+				.withFeatures(features).suppressing(parentBuilder.getSuppressedTests())
-				.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown()).createTestSuite();
+				.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown()).createTestSuite();
-	}
+	}
-
+
-	SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE newBuilderUsing(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate, Bound to, Bound from) {
+	SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE newBuilderUsing(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate, Bound to, Bound from) {
-		return using(new DERIVED_MAP_GENERATORS.SortedMapGeneratorKV_BRACES(delegate, to, from));
+		return using(new DERIVED_MAP_GENERATORS.SortedMapGeneratorKV_BRACES(delegate, to, from));
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestCollectionGenerator.template

@@ -1,30 +1,30 @@
-package speiger.src.testers.PACKAGE.generators;
+package speiger.src.testers.PACKAGE.generators;
-
+
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.SampleElements;
-import com.google.common.collect.testing.TestCollectionGenerator;
+import com.google.common.collect.testing.TestCollectionGenerator;
-
+
-import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE extends TestCollectionGenerator<CLASS_TYPE>
+public interface TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE extends TestCollectionGenerator<CLASS_TYPE>
-{
+{
-	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples();
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples();
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	public COLLECTION KEY_GENERIC_TYPE create(KEY_TYPE...elements);
+	public COLLECTION KEY_GENERIC_TYPE create(KEY_TYPE...elements);
-#endif
+#endif
-	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder);
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder);
-	
+	
-	@Override
+	@Override
-	public default SampleElements<CLASS_TYPE> samples() {return getSamples().toSamples();}
+	public default SampleElements<CLASS_TYPE> samples() {return getSamples().toSamples();}
-	@Override
+	@Override
-	public COLLECTION KEY_GENERIC_TYPE create(Object... elements);
+	public COLLECTION KEY_GENERIC_TYPE create(Object... elements);
-	@Override
+	@Override
-	public default CLASS_TYPE[] createArray(int length) { return NEW_CLASS_ARRAY(length); }
+	public default CLASS_TYPE[] createArray(int length) { return NEW_CLASS_ARRAY(length); }
-	@Override
+	@Override
-	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder);
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder);
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestListGenerator.template

@@ -1,16 +1,16 @@
-package speiger.src.testers.PACKAGE.generators;
+package speiger.src.testers.PACKAGE.generators;
-
+
-import com.google.common.collect.testing.TestListGenerator;
+import com.google.common.collect.testing.TestListGenerator;
-
+
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_LIST_GENERATOR KEY_GENERIC_TYPE extends TestListGenerator<CLASS_TYPE>, TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE
+public interface TEST_LIST_GENERATOR KEY_GENERIC_TYPE extends TestListGenerator<CLASS_TYPE>, TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE
-{
+{
-	@Override
+	@Override
-	LIST KEY_GENERIC_TYPE create(Object... elements);
+	LIST KEY_GENERIC_TYPE create(Object... elements);
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	@Override
+	@Override
-	LIST KEY_GENERIC_TYPE create(KEY_TYPE... elements);
+	LIST KEY_GENERIC_TYPE create(KEY_TYPE... elements);
-#endif
+#endif
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestNavigableSetGenerator.template

@@ -1,13 +1,13 @@
-package speiger.src.testers.PACKAGE.generators;
+package speiger.src.testers.PACKAGE.generators;
-
+
-import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE {
+public interface TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE {
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	@Override
+	@Override
-	NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
+	NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
-#endif
+#endif
-	@Override
+	@Override
-	NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements);
+	NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements);
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestOrderedSetGenerator.template

@@ -1,13 +1,13 @@
-package speiger.src.testers.PACKAGE.generators;
+package speiger.src.testers.PACKAGE.generators;
-
+
-import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SET_GENERATOR KEY_GENERIC_TYPE {
+public interface TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SET_GENERATOR KEY_GENERIC_TYPE {
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	@Override
+	@Override
-	ORDERED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
+	ORDERED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
-#endif
+#endif
-	@Override
+	@Override
-	ORDERED_SET KEY_GENERIC_TYPE create(Object... elements);
+	ORDERED_SET KEY_GENERIC_TYPE create(Object... elements);
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestQueueGenerator.template

@@ -1,30 +1,30 @@
-package speiger.src.testers.PACKAGE.generators;
+package speiger.src.testers.PACKAGE.generators;
-
+
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.SampleElements;
-import com.google.common.collect.testing.TestContainerGenerator;
+import com.google.common.collect.testing.TestContainerGenerator;
-
+
-import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
+import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE extends TestContainerGenerator<PRIORITY_QUEUE KEY_GENERIC_TYPE, CLASS_TYPE>
+public interface TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE extends TestContainerGenerator<PRIORITY_QUEUE KEY_GENERIC_TYPE, CLASS_TYPE>
-{
+{
-	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples();
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples();
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(KEY_TYPE...elements);
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(KEY_TYPE...elements);
-#endif
+#endif
-	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder);
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder);
-	
+	
-	@Override
+	@Override
-	public default SampleElements<CLASS_TYPE> samples() {return getSamples().toSamples();}
+	public default SampleElements<CLASS_TYPE> samples() {return getSamples().toSamples();}
-	@Override
+	@Override
-	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements);
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements);
-	@Override
+	@Override
-	public default CLASS_TYPE[] createArray(int length) { return NEW_CLASS_ARRAY(length); }
+	public default CLASS_TYPE[] createArray(int length) { return NEW_CLASS_ARRAY(length); }
-	@Override
+	@Override
-	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder);
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder);
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestSetGenerator.template

@@ -1,15 +1,15 @@
-package speiger.src.testers.PACKAGE.generators;
+package speiger.src.testers.PACKAGE.generators;
-
+
-import com.google.common.collect.testing.TestSetGenerator;
+import com.google.common.collect.testing.TestSetGenerator;
-
+
-import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.SET;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE, TestSetGenerator<CLASS_TYPE> {
+public interface TEST_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE, TestSetGenerator<CLASS_TYPE> {
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	@Override
+	@Override
-	SET KEY_GENERIC_TYPE create(KEY_TYPE...elements);
+	SET KEY_GENERIC_TYPE create(KEY_TYPE...elements);
-#endif
+#endif
-	@Override
+	@Override
-	SET KEY_GENERIC_TYPE create(Object...elements);
+	SET KEY_GENERIC_TYPE create(Object...elements);
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestSortedSetGenerator.template

@@ -1,38 +1,38 @@
-package speiger.src.testers.PACKAGE.generators;
+package speiger.src.testers.PACKAGE.generators;
-
+
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SET_GENERATOR KEY_GENERIC_TYPE {
+public interface TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SET_GENERATOR KEY_GENERIC_TYPE {
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	@Override
+	@Override
-	SORTED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
+	SORTED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
-#endif
+#endif
-	@Override
+	@Override
-	SORTED_SET KEY_GENERIC_TYPE create(Object... elements);
+	SORTED_SET KEY_GENERIC_TYPE create(Object... elements);
-	
+	
-
+
-	  /**
+	  /**
-	   * Returns an element less than the {@link #samples()} and less than {@link
+	   * Returns an element less than the {@link #samples()} and less than {@link
-	   * #belowSamplesGreater()}.
+	   * #belowSamplesGreater()}.
-	   */
+	   */
-	  KEY_TYPE belowSamplesLesser();
+	  KEY_TYPE belowSamplesLesser();
-
+
-	  /**
+	  /**
-	   * Returns an element less than the {@link #samples()} but greater than {@link
+	   * Returns an element less than the {@link #samples()} but greater than {@link
-	   * #belowSamplesLesser()}.
+	   * #belowSamplesLesser()}.
-	   */
+	   */
-	  KEY_TYPE belowSamplesGreater();
+	  KEY_TYPE belowSamplesGreater();
-
+
-	  /**
+	  /**
-	   * Returns an element greater than the {@link #samples()} but less than {@link
+	   * Returns an element greater than the {@link #samples()} but less than {@link
-	   * #aboveSamplesGreater()}.
+	   * #aboveSamplesGreater()}.
-	   */
+	   */
-	  KEY_TYPE aboveSamplesLesser();
+	  KEY_TYPE aboveSamplesLesser();
-
+
-	  /**
+	  /**
-	   * Returns an element greater than the {@link #samples()} and greater than {@link
+	   * Returns an element greater than the {@link #samples()} and greater than {@link
-	   * #aboveSamplesLesser()}.
+	   * #aboveSamplesLesser()}.
-	   */
+	   */
-	  KEY_TYPE aboveSamplesGreater();
+	  KEY_TYPE aboveSamplesGreater();
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/maps/TestMapGenerator.template

@@ -1,46 +1,46 @@
-package speiger.src.testers.PACKAGE.generators.maps;
+package speiger.src.testers.PACKAGE.generators.maps;
-
+
-import java.util.Map;
+import java.util.Map;
-
+
-import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.Helpers;
-import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.SampleElements;
-import com.google.common.collect.testing.TestMapGenerator;
+import com.google.common.collect.testing.TestMapGenerator;
-
+
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.objects.collections.ObjectIterable;
+import speiger.src.collections.objects.collections.ObjectIterable;
-import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.collections.objects.lists.ObjectList;
-import speiger.src.testers.objects.utils.ObjectSamples;
+import speiger.src.testers.objects.utils.ObjectSamples;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TestMapGenerator<CLASS_TYPE, CLASS_VALUE_TYPE> {
+public interface TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TestMapGenerator<CLASS_TYPE, CLASS_VALUE_TYPE> {
-	public ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSamples();
+	public ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSamples();
-	public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder);
+	public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder);
-	public MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
+	public MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
-	@Override
+	@Override
-	default MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) {
+	default MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) {
-		MAP.Entry KEY_VALUE_GENERIC_TYPE[] result = new MAP.Entry[elements.length];
+		MAP.Entry KEY_VALUE_GENERIC_TYPE[] result = new MAP.Entry[elements.length];
-		for(int i = 0;i<elements.length;i++) {
+		for(int i = 0;i<elements.length;i++) {
-			result[i] = (MAP.Entry KEY_VALUE_GENERIC_TYPE) elements[i];
+			result[i] = (MAP.Entry KEY_VALUE_GENERIC_TYPE) elements[i];
-		}
+		}
-		return create(result);
+		return create(result);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	default CLASS_TYPE[] createKeyArray(int length) { return NEW_CLASS_ARRAY(length); }
+	default CLASS_TYPE[] createKeyArray(int length) { return NEW_CLASS_ARRAY(length); }
-	@Override
+	@Override
-	default CLASS_VALUE_TYPE[] createValueArray(int length) { return NEW_CLASS_VALUE_ARRAY(length); }
+	default CLASS_VALUE_TYPE[] createValueArray(int length) { return NEW_CLASS_VALUE_ARRAY(length); }
-	@Override
+	@Override
-	default MAP.Entry KEY_VALUE_GENERIC_TYPE[] createArray(int length) { return new MAP.Entry[length]; }
+	default MAP.Entry KEY_VALUE_GENERIC_TYPE[] createArray(int length) { return new MAP.Entry[length]; }
-	
+	
-	@Override
+	@Override
-	default SampleElements<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> samples() {
+	default SampleElements<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> samples() {
-		ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> samples = getSamples();
+		ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> samples = getSamples();
-		return new SampleElements<>(
+		return new SampleElements<>(
-			Helpers.mapEntry(samples.e0().ENTRY_KEY(), samples.e0().ENTRY_VALUE()), 
+			Helpers.mapEntry(samples.e0().ENTRY_KEY(), samples.e0().ENTRY_VALUE()), 
-			Helpers.mapEntry(samples.e1().ENTRY_KEY(), samples.e1().ENTRY_VALUE()), 
+			Helpers.mapEntry(samples.e1().ENTRY_KEY(), samples.e1().ENTRY_VALUE()), 
-			Helpers.mapEntry(samples.e2().ENTRY_KEY(), samples.e2().ENTRY_VALUE()), 
+			Helpers.mapEntry(samples.e2().ENTRY_KEY(), samples.e2().ENTRY_VALUE()), 
-			Helpers.mapEntry(samples.e3().ENTRY_KEY(), samples.e3().ENTRY_VALUE()), 
+			Helpers.mapEntry(samples.e3().ENTRY_KEY(), samples.e3().ENTRY_VALUE()), 
-			Helpers.mapEntry(samples.e4().ENTRY_KEY(), samples.e4().ENTRY_VALUE())
+			Helpers.mapEntry(samples.e4().ENTRY_KEY(), samples.e4().ENTRY_VALUE())
-		);
+		);
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/maps/TestOrderedMapGenerator.template

@@ -1,13 +1,13 @@
-package speiger.src.testers.PACKAGE.generators.maps;
+package speiger.src.testers.PACKAGE.generators.maps;
-
+
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+public interface TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
-{
+{
-	@Override
+	@Override
-	default ORDERED_MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) { return (ORDERED_MAP KEY_VALUE_GENERIC_TYPE) TEST_MAP_GENERATOR.super.create(elements); }
+	default ORDERED_MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) { return (ORDERED_MAP KEY_VALUE_GENERIC_TYPE) TEST_MAP_GENERATOR.super.create(elements); }
-	@Override
+	@Override
-	ORDERED_MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
+	ORDERED_MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
-}
+}

src/builder/resources/speiger/assets/testers/templates/generators/maps/TestSortedMapGenerator.template

@@ -1,25 +1,25 @@
-package speiger.src.testers.PACKAGE.generators.maps;
+package speiger.src.testers.PACKAGE.generators.maps;
-
+
-import com.google.common.collect.testing.TestSortedMapGenerator;
+import com.google.common.collect.testing.TestSortedMapGenerator;
-
+
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP.Entry;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP.Entry;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public interface TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE, TestSortedMapGenerator<CLASS_TYPE, CLASS_VALUE_TYPE>
+public interface TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE, TestSortedMapGenerator<CLASS_TYPE, CLASS_VALUE_TYPE>
-{
+{
-	@Override
+	@Override
-	default SORTED_MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) { return (SORTED_MAP KEY_VALUE_GENERIC_TYPE) TEST_MAP_GENERATOR.super.create(elements); }
+	default SORTED_MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) { return (SORTED_MAP KEY_VALUE_GENERIC_TYPE) TEST_MAP_GENERATOR.super.create(elements); }
-	@Override
+	@Override
-	SORTED_MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
+	SORTED_MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
-	
+	
-	@Override
+	@Override
-	Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser();
+	Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser();
-	@Override
+	@Override
-	Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater();
+	Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater();
-	@Override
+	@Override
-	Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser();
+	Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser();
-	@Override
+	@Override
-	Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater();
+	Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater();
-}
+}

src/builder/resources/speiger/assets/testers/templates/impl/CollectionConstructorTests.template

@@ -1,314 +1,314 @@
-package speiger.src.testers.PACKAGE.impl;
+package speiger.src.testers.PACKAGE.impl;
-
+
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.Arrays;
+import java.util.Arrays;
-import java.util.Comparator;
+import java.util.Comparator;
-import java.util.Objects;
+import java.util.Objects;
-#endif
+#endif
-
+
-import org.junit.Ignore;
+import org.junit.Ignore;
-
+
-import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
-import speiger.src.collections.PACKAGE.lists.LINKED_LIST;
+import speiger.src.collections.PACKAGE.lists.LINKED_LIST;
-import speiger.src.collections.PACKAGE.lists.COPY_ON_WRITE_LIST;
+import speiger.src.collections.PACKAGE.lists.COPY_ON_WRITE_LIST;
-import speiger.src.collections.PACKAGE.lists.IMMUTABLE_LIST;
+import speiger.src.collections.PACKAGE.lists.IMMUTABLE_LIST;
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-import speiger.src.collections.PACKAGE.sets.AVL_TREE_SET;
+import speiger.src.collections.PACKAGE.sets.AVL_TREE_SET;
-import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
+import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
-import speiger.src.collections.PACKAGE.sets.LINKED_CUSTOM_HASH_SET;
+import speiger.src.collections.PACKAGE.sets.LINKED_CUSTOM_HASH_SET;
-import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
+import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
-import speiger.src.collections.PACKAGE.sets.CUSTOM_HASH_SET;
+import speiger.src.collections.PACKAGE.sets.CUSTOM_HASH_SET;
-import speiger.src.collections.PACKAGE.sets.HASH_SET;
+import speiger.src.collections.PACKAGE.sets.HASH_SET;
-import speiger.src.collections.PACKAGE.sets.RB_TREE_SET;
+import speiger.src.collections.PACKAGE.sets.RB_TREE_SET;
-import speiger.src.collections.PACKAGE.sets.IMMUTABLE_HASH_SET;
+import speiger.src.collections.PACKAGE.sets.IMMUTABLE_HASH_SET;
-import speiger.src.collections.PACKAGE.utils.STRATEGY;
+import speiger.src.collections.PACKAGE.utils.STRATEGY;
-#endif
+#endif
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import speiger.src.collections.objects.utils.StringSortTest;
+import speiger.src.collections.objects.utils.StringSortTest;
-#endif
+#endif
-import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionConstructorTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionConstructorTester;
-
+
-@Ignore
+@Ignore
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class COLLECTION_CONSTRUCTOR_TESTS
+public class COLLECTION_CONSTRUCTOR_TESTS
-{
+{
-	public static class ArrayList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class ArrayList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public ArrayList() {
+		public ArrayList() {
-			setSimpleConstructor(ARRAY_LIST::new);
+			setSimpleConstructor(ARRAY_LIST::new);
-			setSizeConstructor(T -> new ARRAY_LISTBRACES(T));
+			setSizeConstructor(T -> new ARRAY_LISTBRACES(T));
-			setPArrayConstructor(T -> new ARRAY_LISTBRACES(T));
+			setPArrayConstructor(T -> new ARRAY_LISTBRACES(T));
-			setPCollectionConstructor(T -> new ARRAY_LISTBRACES(T));
+			setPCollectionConstructor(T -> new ARRAY_LISTBRACES(T));
-			setCollectionConstructor(T -> new ARRAY_LISTBRACES(T));
+			setCollectionConstructor(T -> new ARRAY_LISTBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class LinkedList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class LinkedList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public LinkedList() {
+		public LinkedList() {
-			setSimpleConstructor(LINKED_LIST::new);
+			setSimpleConstructor(LINKED_LIST::new);
-			setPArrayConstructor(T -> new LINKED_LISTBRACES(T));
+			setPArrayConstructor(T -> new LINKED_LISTBRACES(T));
-			setPCollectionConstructor(T -> new LINKED_LISTBRACES(T));
+			setPCollectionConstructor(T -> new LINKED_LISTBRACES(T));
-			setCollectionConstructor(T -> new LINKED_LISTBRACES(T));
+			setCollectionConstructor(T -> new LINKED_LISTBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class CopyOnWriteArrayList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class CopyOnWriteArrayList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public CopyOnWriteArrayList() {
+		public CopyOnWriteArrayList() {
-			setSimpleConstructor(COPY_ON_WRITE_LIST::new);
+			setSimpleConstructor(COPY_ON_WRITE_LIST::new);
-			setPArrayConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
+			setPArrayConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
-			setPCollectionConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
+			setPCollectionConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
-			setCollectionConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
+			setCollectionConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class ImmutableList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class ImmutableList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public ImmutableList() {
+		public ImmutableList() {
-			setPArrayConstructor(T -> new IMMUTABLE_LISTBRACES(T));
+			setPArrayConstructor(T -> new IMMUTABLE_LISTBRACES(T));
-			setPCollectionConstructor(T -> new IMMUTABLE_LISTBRACES(T));
+			setPCollectionConstructor(T -> new IMMUTABLE_LISTBRACES(T));
-			setCollectionConstructor(T -> new IMMUTABLE_LISTBRACES(T));
+			setCollectionConstructor(T -> new IMMUTABLE_LISTBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-	public static class HashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class HashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public HashSet() {
+		public HashSet() {
-			setSimpleConstructor(HASH_SET::new);
+			setSimpleConstructor(HASH_SET::new);
-			setSizeConstructor(T -> new HASH_SETBRACES(T));
+			setSizeConstructor(T -> new HASH_SETBRACES(T));
-			setPArrayConstructor(T -> new HASH_SETBRACES(T));
+			setPArrayConstructor(T -> new HASH_SETBRACES(T));
-			setPCollectionConstructor(T -> new HASH_SETBRACES(T));
+			setPCollectionConstructor(T -> new HASH_SETBRACES(T));
-			setCollectionConstructor(T -> new HASH_SETBRACES(T));
+			setCollectionConstructor(T -> new HASH_SETBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class LinkedHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class LinkedHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public LinkedHashSet() {
+		public LinkedHashSet() {
-			setSimpleConstructor(LINKED_HASH_SET::new);
+			setSimpleConstructor(LINKED_HASH_SET::new);
-			setSizeConstructor(T -> new LINKED_HASH_SETBRACES(T));
+			setSizeConstructor(T -> new LINKED_HASH_SETBRACES(T));
-			setPArrayConstructor(T -> new LINKED_HASH_SETBRACES(T));
+			setPArrayConstructor(T -> new LINKED_HASH_SETBRACES(T));
-			setPCollectionConstructor(T -> new LINKED_HASH_SETBRACES(T));
+			setPCollectionConstructor(T -> new LINKED_HASH_SETBRACES(T));
-			setCollectionConstructor(T -> new LINKED_HASH_SETBRACES(T));
+			setCollectionConstructor(T -> new LINKED_HASH_SETBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class CustomHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class CustomHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public CustomHashSet() {
+		public CustomHashSet() {
-			setSimpleConstructor(() -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(HashStrategy.INSTANCE));
+			setSimpleConstructor(() -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(HashStrategy.INSTANCE));
-			setSizeConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setSizeConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
-			setPArrayConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setPArrayConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
-			setPCollectionConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setPCollectionConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
-			setCollectionConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setCollectionConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class LinkedCustomHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class LinkedCustomHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public LinkedCustomHashSet() {
+		public LinkedCustomHashSet() {
-			setSimpleConstructor(() -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(HashStrategy.INSTANCE));
+			setSimpleConstructor(() -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(HashStrategy.INSTANCE));
-			setSizeConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setSizeConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
-			setPArrayConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setPArrayConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
-			setPCollectionConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setPCollectionConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
-			setCollectionConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setCollectionConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class ImmutableHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class ImmutableHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public ImmutableHashSet() {
+		public ImmutableHashSet() {
-			setPArrayConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
+			setPArrayConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
-			setPCollectionConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
+			setPCollectionConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
-			setCollectionConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
+			setCollectionConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class ArraySet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class ArraySet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public ArraySet() {
+		public ArraySet() {
-			setSimpleConstructor(ARRAY_SET::new);
+			setSimpleConstructor(ARRAY_SET::new);
-			setSizeConstructor(T -> new ARRAY_SETBRACES(T));
+			setSizeConstructor(T -> new ARRAY_SETBRACES(T));
-			setPArrayConstructor(T -> new ARRAY_SETBRACES(T));
+			setPArrayConstructor(T -> new ARRAY_SETBRACES(T));
-			setPCollectionConstructor(T -> new ARRAY_SETBRACES(T));
+			setPCollectionConstructor(T -> new ARRAY_SETBRACES(T));
-			setCollectionConstructor(T -> new ARRAY_SETBRACES(T));
+			setCollectionConstructor(T -> new ARRAY_SETBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class RBTreeSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class RBTreeSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public RBTreeSet() {
+		public RBTreeSet() {
-			setSimpleConstructor(RB_TREE_SET::new);
+			setSimpleConstructor(RB_TREE_SET::new);
-			setPArrayConstructor(T -> new RB_TREE_SETBRACES(T));
+			setPArrayConstructor(T -> new RB_TREE_SETBRACES(T));
-			setPCollectionConstructor(T -> new RB_TREE_SETBRACES(T));
+			setPCollectionConstructor(T -> new RB_TREE_SETBRACES(T));
-			setCollectionConstructor(T -> new RB_TREE_SETBRACES(T));
+			setCollectionConstructor(T -> new RB_TREE_SETBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class AVLTreeSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class AVLTreeSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public AVLTreeSet() {
+		public AVLTreeSet() {
-			setSimpleConstructor(AVL_TREE_SET::new);
+			setSimpleConstructor(AVL_TREE_SET::new);
-			setPArrayConstructor(T -> new AVL_TREE_SETBRACES(T));
+			setPArrayConstructor(T -> new AVL_TREE_SETBRACES(T));
-			setPCollectionConstructor(T -> new AVL_TREE_SETBRACES(T));
+			setPCollectionConstructor(T -> new AVL_TREE_SETBRACES(T));
-			setCollectionConstructor(T -> new AVL_TREE_SETBRACES(T));
+			setCollectionConstructor(T -> new AVL_TREE_SETBRACES(T));
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class RBTreeSetComparator extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class RBTreeSetComparator extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public RBTreeSetComparator() {
+		public RBTreeSetComparator() {
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-			setSimpleConstructor(() -> new RB_TREE_SET<String>(Comparator.naturalOrder()));
+			setSimpleConstructor(() -> new RB_TREE_SET<String>(Comparator.naturalOrder()));
-			setPArrayConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
+			setPArrayConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
-			setPCollectionConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
+			setPCollectionConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
-			setCollectionConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
+			setCollectionConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
-#else
+#else
-			setSimpleConstructor(() -> new RB_TREE_SET(CLASS_TYPE::compare));
+			setSimpleConstructor(() -> new RB_TREE_SET(CLASS_TYPE::compare));
-			setPArrayConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
+			setPArrayConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
-			setPCollectionConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
+			setPCollectionConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
-			setCollectionConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
+			setCollectionConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
-#endif
+#endif
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class AVLTreeSetComparator extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	public static class AVLTreeSetComparator extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
-	{
+	{
-		@SuppressWarnings("deprecation")
+		@SuppressWarnings("deprecation")
-		public AVLTreeSetComparator() {
+		public AVLTreeSetComparator() {
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-			setSimpleConstructor(() -> new AVL_TREE_SET<String>(Comparator.naturalOrder()));
+			setSimpleConstructor(() -> new AVL_TREE_SET<String>(Comparator.naturalOrder()));
-			setPArrayConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
+			setPArrayConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
-			setPCollectionConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
+			setPCollectionConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
-			setCollectionConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
+			setCollectionConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
-#else
+#else
-			setSimpleConstructor(() -> new AVL_TREE_SET(CLASS_TYPE::compare));
+			setSimpleConstructor(() -> new AVL_TREE_SET(CLASS_TYPE::compare));
-			setPArrayConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
+			setPArrayConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
-			setPCollectionConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
+			setPCollectionConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
-			setCollectionConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
+			setCollectionConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
-#endif
+#endif
-		}
+		}
-		
+		
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		@Override
+		@Override
-		protected String[] createKeyElements() {
+		protected String[] createKeyElements() {
-			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
-		}
+		}
-#endif
+#endif
-	}
+	}
-	
+	
-	private static class HashStrategy implements STRATEGY KEY_STRING_GENERIC_TYPE {
+	private static class HashStrategy implements STRATEGY KEY_STRING_GENERIC_TYPE {
-		static final HashStrategy INSTANCE = new HashStrategy();
+		static final HashStrategy INSTANCE = new HashStrategy();
-		@Override
+		@Override
-		public int hashCode(KEY_STRING_TYPE o) { return KEY_TO_HASH(o); }
+		public int hashCode(KEY_STRING_TYPE o) { return KEY_TO_HASH(o); }
-		@Override
+		@Override
-		public boolean equals(KEY_STRING_TYPE key, KEY_STRING_TYPE value) { return KEY_EQUALS(key, value); }
+		public boolean equals(KEY_STRING_TYPE key, KEY_STRING_TYPE value) { return KEY_EQUALS(key, value); }
-	}
+	}
-#endif
+#endif
 }

src/builder/resources/speiger/assets/testers/templates/impl/SimpleQueueTestGenerator.template

@@ -1,82 +1,82 @@
-package speiger.src.testers.PACKAGE.impl;
+package speiger.src.testers.PACKAGE.impl;
-
+
-import java.util.List;
+import java.util.List;
-import java.util.function.Function;
+import java.util.function.Function;
-
+
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
+import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import speiger.src.collections.objects.utils.ObjectArrays;
+import speiger.src.collections.objects.utils.ObjectArrays;
-#endif
+#endif
-import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class SIMPLE_QUEUE_TEST_GENERATOR KEY_GENERIC_TYPE implements TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE
+public class SIMPLE_QUEUE_TEST_GENERATOR KEY_GENERIC_TYPE implements TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE
-{
+{
-	Function<KEY_TYPE[], PRIORITY_QUEUE KEY_GENERIC_TYPE> mapper;
+	Function<KEY_TYPE[], PRIORITY_QUEUE KEY_GENERIC_TYPE> mapper;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-	KEY_TYPE[] keys;
+	KEY_TYPE[] keys;
-#endif
+#endif
-	
+	
-	public SIMPLE_QUEUE_TEST_GENERATOR(Function<KEY_TYPE[], PRIORITY_QUEUE KEY_GENERIC_TYPE> mapper) {
+	public SIMPLE_QUEUE_TEST_GENERATOR(Function<KEY_TYPE[], PRIORITY_QUEUE KEY_GENERIC_TYPE> mapper) {
-		this.mapper = mapper;
+		this.mapper = mapper;
-	}
+	}
-	
+	
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-	public SIMPLE_QUEUE_TEST_GENERATOR KEY_GENERIC_TYPE setElements(KEY_TYPE...keys) {
+	public SIMPLE_QUEUE_TEST_GENERATOR KEY_GENERIC_TYPE setElements(KEY_TYPE...keys) {
-		this.keys = keys;
+		this.keys = keys;
-		return this;
+		return this;
-	}
+	}
-	
+	
-#endif
+#endif
-	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
-#if TYPE_BOOLEAN
+#if TYPE_BOOLEAN
-		return new SAMPLE_ELEMENTS(true, false, true, false, true);
+		return new SAMPLE_ELEMENTS(true, false, true, false, true);
-#else if TYPE_BYTE
+#else if TYPE_BYTE
-		return new SAMPLE_ELEMENTS((byte)0, (byte)1, (byte)2, (byte)3, (byte)4);
+		return new SAMPLE_ELEMENTS((byte)0, (byte)1, (byte)2, (byte)3, (byte)4);
-#else if TYPE_SHORT
+#else if TYPE_SHORT
-		return new SAMPLE_ELEMENTS((short)0, (short)1, (short)2, (short)3, (short)4);
+		return new SAMPLE_ELEMENTS((short)0, (short)1, (short)2, (short)3, (short)4);
-#else if TYPE_CHAR
+#else if TYPE_CHAR
-		return new SAMPLE_ELEMENTS((char)0, (char)1, (char)2, (char)3, (char)4);
+		return new SAMPLE_ELEMENTS((char)0, (char)1, (char)2, (char)3, (char)4);
-#else if TYPE_OBJECT
+#else if TYPE_OBJECT
-		return new SAMPLE_ELEMENTSBRACES(keys[0], keys[1], keys[2], keys[3], keys[4]);
+		return new SAMPLE_ELEMENTSBRACES(keys[0], keys[1], keys[2], keys[3], keys[4]);
-#else
+#else
-		return new SAMPLE_ELEMENTS(0, 1, 2, 3, 4);
+		return new SAMPLE_ELEMENTS(0, 1, 2, 3, 4);
-#endif
+#endif
-	}
+	}
-	
+	
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
-		return mapper.apply(elements);
+		return mapper.apply(elements);
-	}
+	}
-	
+	
-	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements) {
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements) {
-		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
+		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
-		int i = 0;
+		int i = 0;
-		for (Object e : elements) {
+		for (Object e : elements) {
-			array[i++] = CLASS_TO_KEY(e);
+			array[i++] = CLASS_TO_KEY(e);
-		}
+		}
-		return mapper.apply(array);
+		return mapper.apply(array);
-	}
+	}
-	
+	
-#else
+#else
-	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements) {
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements) {
-		T[] array = (T[])ObjectArrays.newArray(keys[0].getClass(), elements.length);
+		T[] array = (T[])ObjectArrays.newArray(keys[0].getClass(), elements.length);
-		int i = 0;
+		int i = 0;
-		for (Object e : elements) {
+		for (Object e : elements) {
-			array[i++] = CLASS_TO_KEY(e);
+			array[i++] = CLASS_TO_KEY(e);
-		}
+		}
-		return mapper.apply(array);
+		return mapper.apply(array);
-	}
+	}
-
+
-#endif
+#endif
-	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
-		return insertionOrder;
+		return insertionOrder;
-	}
+	}
-	
+	
-	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
-		return insertionOrder;
+		return insertionOrder;
-	}
+	}
 }

src/builder/resources/speiger/assets/testers/templates/impl/SimpleTestGenerator.template

@@ -1,221 +1,221 @@
-package speiger.src.testers.PACKAGE.impl;
+package speiger.src.testers.PACKAGE.impl;
-
+
-import java.util.List;
+import java.util.List;
-import java.util.function.Function;
+import java.util.function.Function;
-
+
-import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
-import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
-import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import speiger.src.collections.objects.utils.ObjectArrays;
+import speiger.src.collections.objects.utils.ObjectArrays;
-#endif
+#endif
-#endif
+#endif
-import speiger.src.testers.PACKAGE.generators.TEST_COLLECTION_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_COLLECTION_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_LIST_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_LIST_GENERATOR;
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
-#endif
+#endif
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<E extends COLLECTION KEY_GENERIC_TYPE> {
+public class SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<E extends COLLECTION KEY_GENERIC_TYPE> {
-	Function<KEY_TYPE[], E> mapper;
+	Function<KEY_TYPE[], E> mapper;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-	KEY_TYPE[] keys;
+	KEY_TYPE[] keys;
-#endif
+#endif
-	
+	
-	public SIMPLE_TEST_GENERATOR(Function<KEY_TYPE[], E> mapper) {
+	public SIMPLE_TEST_GENERATOR(Function<KEY_TYPE[], E> mapper) {
-		this.mapper = mapper;
+		this.mapper = mapper;
-	}
+	}
-	
+	
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-	public SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<E> setElements(KEY_TYPE...keys) {
+	public SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<E> setElements(KEY_TYPE...keys) {
-		this.keys = keys;
+		this.keys = keys;
-		return this;
+		return this;
-	}
+	}
-	
+	
-#endif
+#endif
-	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
-#if TYPE_BOOLEAN
+#if TYPE_BOOLEAN
-		return new SAMPLE_ELEMENTS(true, false, true, false, true);
+		return new SAMPLE_ELEMENTS(true, false, true, false, true);
-#else if TYPE_BYTE
+#else if TYPE_BYTE
-		return new SAMPLE_ELEMENTS((byte)0, (byte)1, (byte)2, (byte)3, (byte)4);
+		return new SAMPLE_ELEMENTS((byte)0, (byte)1, (byte)2, (byte)3, (byte)4);
-#else if TYPE_SHORT
+#else if TYPE_SHORT
-		return new SAMPLE_ELEMENTS((short)0, (short)1, (short)2, (short)3, (short)4);
+		return new SAMPLE_ELEMENTS((short)0, (short)1, (short)2, (short)3, (short)4);
-#else if TYPE_CHAR
+#else if TYPE_CHAR
-		return new SAMPLE_ELEMENTS((char)0, (char)1, (char)2, (char)3, (char)4);
+		return new SAMPLE_ELEMENTS((char)0, (char)1, (char)2, (char)3, (char)4);
-#else if TYPE_OBJECT
+#else if TYPE_OBJECT
-		return new SAMPLE_ELEMENTSBRACES(keys[0], keys[1], keys[2], keys[3], keys[4]);
+		return new SAMPLE_ELEMENTSBRACES(keys[0], keys[1], keys[2], keys[3], keys[4]);
-#else
+#else
-		return new SAMPLE_ELEMENTS(0, 1, 2, 3, 4);
+		return new SAMPLE_ELEMENTS(0, 1, 2, 3, 4);
-#endif
+#endif
-	}
+	}
-	
+	
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	public E create(KEY_TYPE... elements) {
+	public E create(KEY_TYPE... elements) {
-		return mapper.apply(elements);
+		return mapper.apply(elements);
-	}
+	}
-	
+	
-	public E create(Object... elements) {
+	public E create(Object... elements) {
-		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
+		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
-		int i = 0;
+		int i = 0;
-		for (Object e : elements) {
+		for (Object e : elements) {
-			array[i++] = CLASS_TO_KEY(e);
+			array[i++] = CLASS_TO_KEY(e);
-		}
+		}
-		return mapper.apply(array);
+		return mapper.apply(array);
-	}
+	}
-	
+	
-#else
+#else
-	public E create(Object... elements) {
+	public E create(Object... elements) {
-		T[] array = (T[])ObjectArrays.newArray(keys[0].getClass(), elements.length);
+		T[] array = (T[])ObjectArrays.newArray(keys[0].getClass(), elements.length);
-		int i = 0;
+		int i = 0;
-		for (Object e : elements) {
+		for (Object e : elements) {
-			array[i++] = CLASS_TO_KEY(e);
+			array[i++] = CLASS_TO_KEY(e);
-		}
+		}
-		return mapper.apply(array);
+		return mapper.apply(array);
-	}
+	}
-
+
-#endif
+#endif
-	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
-		return insertionOrder;
+		return insertionOrder;
-	}
+	}
-	
+	
-	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
-		return insertionOrder;
+		return insertionOrder;
-	}
+	}
-	
+	
-	public static class Collections KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<COLLECTION KEY_GENERIC_TYPE> implements TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE
+	public static class Collections KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<COLLECTION KEY_GENERIC_TYPE> implements TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE
-	{
+	{
-		public Collections(Function<KEY_TYPE[], COLLECTION KEY_GENERIC_TYPE> mapper) {
+		public Collections(Function<KEY_TYPE[], COLLECTION KEY_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-		}
+		}
-	}
+	}
-	
+	
-	public static class Lists KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<LIST KEY_GENERIC_TYPE> implements TEST_LIST_GENERATOR KEY_GENERIC_TYPE
+	public static class Lists KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<LIST KEY_GENERIC_TYPE> implements TEST_LIST_GENERATOR KEY_GENERIC_TYPE
-	{
+	{
-		public Lists(Function<KEY_TYPE[], LIST KEY_GENERIC_TYPE> mapper) {
+		public Lists(Function<KEY_TYPE[], LIST KEY_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-		}
+		}
-	}
+	}
-	
+	
-#if !TYPE_BOOLEAN
+#if !TYPE_BOOLEAN
-	public static class Sets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<SET KEY_GENERIC_TYPE> implements TEST_SET_GENERATOR KEY_GENERIC_TYPE
+	public static class Sets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<SET KEY_GENERIC_TYPE> implements TEST_SET_GENERATOR KEY_GENERIC_TYPE
-	{
+	{
-		public Sets(Function<KEY_TYPE[], SET KEY_GENERIC_TYPE> mapper) {
+		public Sets(Function<KEY_TYPE[], SET KEY_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-		}
+		}
-	}
+	}
-	
+	
-	public static class OrderedSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<ORDERED_SET KEY_GENERIC_TYPE> implements TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE
+	public static class OrderedSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<ORDERED_SET KEY_GENERIC_TYPE> implements TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE
-	{
+	{
-		public OrderedSets(Function<KEY_TYPE[], ORDERED_SET KEY_GENERIC_TYPE> mapper) {
+		public OrderedSets(Function<KEY_TYPE[], ORDERED_SET KEY_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-		}
+		}
-	}
+	}
-	
+	
-	public static class SortedSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<SORTED_SET KEY_GENERIC_TYPE> implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE
+	public static class SortedSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<SORTED_SET KEY_GENERIC_TYPE> implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE
-	{
+	{
-		public SortedSets(Function<KEY_TYPE[], SORTED_SET KEY_GENERIC_TYPE> mapper) {
+		public SortedSets(Function<KEY_TYPE[], SORTED_SET KEY_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
-			insertionOrder.sort(null);
+			insertionOrder.sort(null);
-			return insertionOrder;
+			return insertionOrder;
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
-			insertionOrder.sort(null);
+			insertionOrder.sort(null);
-			return insertionOrder;
+			return insertionOrder;
-		}
+		}
-		
+		
-#if TYPE_CHAR
+#if TYPE_CHAR
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesLesser() { return '_'; }
+		public KEY_TYPE belowSamplesLesser() { return '_'; }
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesGreater() { return '`'; }
+		public KEY_TYPE belowSamplesGreater() { return '`'; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesLesser() { return 'f'; }
+		public KEY_TYPE aboveSamplesLesser() { return 'f'; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesGreater() { return 'g'; }
+		public KEY_TYPE aboveSamplesGreater() { return 'g'; }
-#else if TYPE_OBJECT
+#else if TYPE_OBJECT
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesLesser() { return keys[5]; }
+		public KEY_TYPE belowSamplesLesser() { return keys[5]; }
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesGreater() { return keys[6]; }
+		public KEY_TYPE belowSamplesGreater() { return keys[6]; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesLesser() { return keys[7]; }
+		public KEY_TYPE aboveSamplesLesser() { return keys[7]; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesGreater() { return keys[8]; }
+		public KEY_TYPE aboveSamplesGreater() { return keys[8]; }
-#else
+#else
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesLesser() { return -2; }
+		public KEY_TYPE belowSamplesLesser() { return -2; }
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesGreater() { return -1; }
+		public KEY_TYPE belowSamplesGreater() { return -1; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesLesser() { return 5; }
+		public KEY_TYPE aboveSamplesLesser() { return 5; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesGreater() { return 6; }
+		public KEY_TYPE aboveSamplesGreater() { return 6; }
-#endif
+#endif
-	}
+	}
-	
+	
-	public static class NavigableSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<NAVIGABLE_SET KEY_GENERIC_TYPE> implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE
+	public static class NavigableSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<NAVIGABLE_SET KEY_GENERIC_TYPE> implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE
-	{
+	{
-		public NavigableSets(Function<KEY_TYPE[], NAVIGABLE_SET KEY_GENERIC_TYPE> mapper) {
+		public NavigableSets(Function<KEY_TYPE[], NAVIGABLE_SET KEY_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
-			insertionOrder.sort(null);
+			insertionOrder.sort(null);
-			return insertionOrder;
+			return insertionOrder;
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
-			insertionOrder.sort(null);
+			insertionOrder.sort(null);
-			return insertionOrder;
+			return insertionOrder;
-		}
+		}
-		
+		
-#if TYPE_CHAR
+#if TYPE_CHAR
-		public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() { return new SAMPLE_ELEMENTS('a', 'b', 'c', 'd', 'e'); }
+		public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() { return new SAMPLE_ELEMENTS('a', 'b', 'c', 'd', 'e'); }
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesLesser() { return '_'; }
+		public KEY_TYPE belowSamplesLesser() { return '_'; }
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesGreater() { return '`'; }
+		public KEY_TYPE belowSamplesGreater() { return '`'; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesLesser() { return 'f'; }
+		public KEY_TYPE aboveSamplesLesser() { return 'f'; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesGreater() { return 'g'; }
+		public KEY_TYPE aboveSamplesGreater() { return 'g'; }
-#else if TYPE_OBJECT
+#else if TYPE_OBJECT
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesLesser() { return keys[5]; }
+		public KEY_TYPE belowSamplesLesser() { return keys[5]; }
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesGreater() { return keys[6]; }
+		public KEY_TYPE belowSamplesGreater() { return keys[6]; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesLesser() { return keys[7]; }
+		public KEY_TYPE aboveSamplesLesser() { return keys[7]; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesGreater() { return keys[8]; }
+		public KEY_TYPE aboveSamplesGreater() { return keys[8]; }
-#else
+#else
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesLesser() { return -2; }
+		public KEY_TYPE belowSamplesLesser() { return -2; }
-		@Override
+		@Override
-		public KEY_TYPE belowSamplesGreater() { return -1; }
+		public KEY_TYPE belowSamplesGreater() { return -1; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesLesser() { return 5; }
+		public KEY_TYPE aboveSamplesLesser() { return 5; }
-		@Override
+		@Override
-		public KEY_TYPE aboveSamplesGreater() { return 6; }
+		public KEY_TYPE aboveSamplesGreater() { return 6; }
-#endif
+#endif
-	}
+	}
-#endif
+#endif
 }

src/builder/resources/speiger/assets/testers/templates/impl/SortedSetSubsetTestSetGenerator.template

@@ -1,173 +1,173 @@
-package speiger.src.testers.PACKAGE.impl;
+package speiger.src.testers.PACKAGE.impl;
-
+
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.Comparator;
+import java.util.Comparator;
-#endif
+#endif
-import java.util.List;
+import java.util.List;
-
+
-import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
-
+
-import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
-#endif
+#endif
-import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
-import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class SUB_SORTED_SET_CLASS_GENERATOR KEY_GENERIC_TYPE implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE
+public class SUB_SORTED_SET_CLASS_GENERATOR KEY_GENERIC_TYPE implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE
-{
+{
-	final Bound to;
+	final Bound to;
-	final Bound from;
+	final Bound from;
-	final KEY_TYPE firstInclusive;
+	final KEY_TYPE firstInclusive;
-	final KEY_TYPE lastInclusive;
+	final KEY_TYPE lastInclusive;
-	private final COMPARATOR KEY_GENERIC_TYPE comparator;
+	private final COMPARATOR KEY_GENERIC_TYPE comparator;
-	private final TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate;
+	private final TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate;
-
+
-	public SUB_SORTED_SET_CLASS_GENERATOR(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
+	public SUB_SORTED_SET_CLASS_GENERATOR(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
-		this.to = to;
+		this.to = to;
-		this.from = from;
+		this.from = from;
-		this.delegate = delegate;
+		this.delegate = delegate;
-
+
-		SORTED_SET KEY_GENERIC_TYPE emptySet = delegate.create(NEW_KEY_ARRAY(0));
+		SORTED_SET KEY_GENERIC_TYPE emptySet = delegate.create(NEW_KEY_ARRAY(0));
-		comparator = emptySet.comparator();
+		comparator = emptySet.comparator();
-
+
-		SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples = delegate.getSamples();
+		SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples = delegate.getSamples();
-		LIST KEY_GENERIC_TYPE samplesList = new ARRAY_LISTBRACES(samples.asList());
+		LIST KEY_GENERIC_TYPE samplesList = new ARRAY_LISTBRACES(samples.asList());
-		samplesList.sort(comparator);
+		samplesList.sort(comparator);
-		firstInclusive = samplesList.GET_KEY(0);
+		firstInclusive = samplesList.GET_KEY(0);
-		lastInclusive = samplesList.GET_KEY(samplesList.size() - 1);
+		lastInclusive = samplesList.GET_KEY(samplesList.size() - 1);
-	}
+	}
-
+
-	public final TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE getInnerGenerator() {
+	public final TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE getInnerGenerator() {
-		return delegate;
+		return delegate;
-	}
+	}
-
+
-	public final Bound getTo() {
+	public final Bound getTo() {
-		return to;
+		return to;
-	}
+	}
-
+
-	public final Bound getFrom() {
+	public final Bound getFrom() {
-		return from;
+		return from;
-	}
+	}
-
+
-	SORTED_SET KEY_GENERIC_TYPE createSubSet(SORTED_SET KEY_GENERIC_TYPE set, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
+	SORTED_SET KEY_GENERIC_TYPE createSubSet(SORTED_SET KEY_GENERIC_TYPE set, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
-		if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
+		if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
-			return set.headSet(lastExclusive);
+			return set.headSet(lastExclusive);
-		} else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
+		} else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
-			return set.tailSet(firstInclusive);
+			return set.tailSet(firstInclusive);
-		} else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
+		} else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
-			return set.subSet(firstInclusive, lastExclusive);
+			return set.subSet(firstInclusive, lastExclusive);
-		} else {
+		} else {
-			throw new IllegalArgumentException();
+			throw new IllegalArgumentException();
-		}
+		}
-	}
+	}
-
+
-	@Override
+	@Override
-	public KEY_TYPE belowSamplesLesser() {
+	public KEY_TYPE belowSamplesLesser() {
-		throw new UnsupportedOperationException();
+		throw new UnsupportedOperationException();
-	}
+	}
-
+
-	@Override
+	@Override
-	public KEY_TYPE belowSamplesGreater() {
+	public KEY_TYPE belowSamplesGreater() {
-		throw new UnsupportedOperationException();
+		throw new UnsupportedOperationException();
-	}
+	}
-
+
-	@Override
+	@Override
-	public KEY_TYPE aboveSamplesLesser() {
+	public KEY_TYPE aboveSamplesLesser() {
-		throw new UnsupportedOperationException();
+		throw new UnsupportedOperationException();
-	}
+	}
-
+
-	@Override
+	@Override
-	public KEY_TYPE aboveSamplesGreater() {
+	public KEY_TYPE aboveSamplesGreater() {
-		throw new UnsupportedOperationException();
+		throw new UnsupportedOperationException();
-	}
+	}
-
+
-	@Override
+	@Override
-	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
-		return delegate.getSamples();
+		return delegate.getSamples();
-	}
+	}
-
+
-	@Override
+	@Override
-	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
-		return delegate.order(insertionOrder);
+		return delegate.order(insertionOrder);
-	}
+	}
-
+
-	@Override
+	@Override
-	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
-		return delegate.order(insertionOrder);
+		return delegate.order(insertionOrder);
-	}
+	}
-
+
-	@Override
+	@Override
-	public SORTED_SET KEY_GENERIC_TYPE create(KEY_OBJECT_TYPE... elements) {
+	public SORTED_SET KEY_GENERIC_TYPE create(KEY_OBJECT_TYPE... elements) {
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		LIST KEY_GENERIC_TYPE normalValues = (LIST KEY_GENERIC_TYPE)ARRAY_LIST.wrap(elements);
+		LIST KEY_GENERIC_TYPE normalValues = (LIST KEY_GENERIC_TYPE)ARRAY_LIST.wrap(elements);
-#else
+#else
-		LIST KEY_GENERIC_TYPE normalValues = ARRAY_LIST.wrap(elements);
+		LIST KEY_GENERIC_TYPE normalValues = ARRAY_LIST.wrap(elements);
-#endif
+#endif
-		LIST KEY_GENERIC_TYPE extremeValues = new ARRAY_LISTBRACES();
+		LIST KEY_GENERIC_TYPE extremeValues = new ARRAY_LISTBRACES();
-		KEY_TYPE firstExclusive = delegate.belowSamplesGreater();
+		KEY_TYPE firstExclusive = delegate.belowSamplesGreater();
-		KEY_TYPE lastExclusive = delegate.aboveSamplesLesser();
+		KEY_TYPE lastExclusive = delegate.aboveSamplesLesser();
-		if (from != Bound.NO_BOUND) {
+		if (from != Bound.NO_BOUND) {
-			extremeValues.add(delegate.belowSamplesLesser());
+			extremeValues.add(delegate.belowSamplesLesser());
-			extremeValues.add(delegate.belowSamplesGreater());
+			extremeValues.add(delegate.belowSamplesGreater());
-		}
+		}
-		if (to != Bound.NO_BOUND) {
+		if (to != Bound.NO_BOUND) {
-			extremeValues.add(delegate.aboveSamplesLesser());
+			extremeValues.add(delegate.aboveSamplesLesser());
-			extremeValues.add(delegate.aboveSamplesGreater());
+			extremeValues.add(delegate.aboveSamplesGreater());
-		}
+		}
-		LIST KEY_GENERIC_TYPE allEntries = new ARRAY_LISTBRACES();
+		LIST KEY_GENERIC_TYPE allEntries = new ARRAY_LISTBRACES();
-		allEntries.addAll(extremeValues);
+		allEntries.addAll(extremeValues);
-		allEntries.addAll(normalValues);
+		allEntries.addAll(normalValues);
-		SORTED_SET KEY_GENERIC_TYPE set = delegate.create(allEntries.toArray());
+		SORTED_SET KEY_GENERIC_TYPE set = delegate.create(allEntries.toArray());
-
+
-		return createSubSet(set, firstExclusive, lastExclusive);
+		return createSubSet(set, firstExclusive, lastExclusive);
-	}
+	}
-	
+	
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-	@Override
+	@Override
-	public SORTED_SET KEY_GENERIC_TYPE create(Object... elements) {
+	public SORTED_SET KEY_GENERIC_TYPE create(Object... elements) {
-		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
+		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
-		int i = 0;
+		int i = 0;
-		for (Object e : elements) {
+		for (Object e : elements) {
-			array[i++] = CLASS_TO_KEY(e);
+			array[i++] = CLASS_TO_KEY(e);
-		}
+		}
-		return create(array);
+		return create(array);
-	}
+	}
-
+
-#endif
+#endif
-	public static final class SUB_NAVIGABLE_SET_CLASS_GENERATOR KEY_GENERIC_TYPE extends SUB_SORTED_SET_CLASS_GENERATOR KEY_GENERIC_TYPE implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE {
+	public static final class SUB_NAVIGABLE_SET_CLASS_GENERATOR KEY_GENERIC_TYPE extends SUB_SORTED_SET_CLASS_GENERATOR KEY_GENERIC_TYPE implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE {
-		public SUB_NAVIGABLE_SET_CLASS_GENERATOR(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
+		public SUB_NAVIGABLE_SET_CLASS_GENERATOR(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
-			super(delegate, to, from);
+			super(delegate, to, from);
-		}
+		}
-		
+		
-#if !TYPE_OBJECT
+#if !TYPE_OBJECT
-		@Override
+		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+		public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
-			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.create(elements);
+			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.create(elements);
-		}
+		}
-		
+		
-#endif
+#endif
-		@Override
+		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
+		public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
-			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.create(elements);
+			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.create(elements);
-		}
+		}
-		
+		
-		@Override
+		@Override
-		NAVIGABLE_SET KEY_GENERIC_TYPE createSubSet(SORTED_SET KEY_GENERIC_TYPE sortedSet, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
+		NAVIGABLE_SET KEY_GENERIC_TYPE createSubSet(SORTED_SET KEY_GENERIC_TYPE sortedSet, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
-			NAVIGABLE_SET KEY_GENERIC_TYPE set = (NAVIGABLE_SET KEY_GENERIC_TYPE) sortedSet;
+			NAVIGABLE_SET KEY_GENERIC_TYPE set = (NAVIGABLE_SET KEY_GENERIC_TYPE) sortedSet;
-			if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) return set.headSet(lastInclusive, true);	
+			if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) return set.headSet(lastInclusive, true);	
-			else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) return set.tailSet(firstExclusive, false);	
+			else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) return set.tailSet(firstExclusive, false);	
-			else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) return set.subSet(firstExclusive, false, lastExclusive, false);
+			else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) return set.subSet(firstExclusive, false, lastExclusive, false);
-			else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) return set.subSet(firstExclusive, false, lastInclusive, true);
+			else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) return set.subSet(firstExclusive, false, lastInclusive, true);
-			else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) return set.subSet(firstInclusive, true, lastInclusive, true);
+			else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) return set.subSet(firstInclusive, true, lastInclusive, true);
-			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.createSubSet(set, firstExclusive, lastExclusive);
+			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.createSubSet(set, firstExclusive, lastExclusive);
-
+
-		}
+		}
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/impl/maps/SimpleMapTestGenerator.template

@@ -1,200 +1,200 @@
-package speiger.src.testers.PACKAGE.impl.maps;
+package speiger.src.testers.PACKAGE.impl.maps;
-
+
-import java.util.Comparator;
+import java.util.Comparator;
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-import java.util.Objects;
+import java.util.Objects;
-#endif
+#endif
-import java.util.function.BiFunction;
+import java.util.function.BiFunction;
-import java.util.function.Consumer;
+import java.util.function.Consumer;
-
+
-import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
+import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.CONCURRENT_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.CONCURRENT_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
-import speiger.src.collections.objects.collections.ObjectIterable;
+import speiger.src.collections.objects.collections.ObjectIterable;
-#if TYPE_OBJECT || VALUE_OBJECT
+#if TYPE_OBJECT || VALUE_OBJECT
-import speiger.src.collections.objects.utils.ObjectArrays;
+import speiger.src.collections.objects.utils.ObjectArrays;
-#endif
+#endif
-import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.collections.objects.lists.ObjectList;
-import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.collections.objects.lists.ObjectArrayList;
-import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
-import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
-import speiger.src.testers.objects.utils.ObjectSamples;
+import speiger.src.testers.objects.utils.ObjectSamples;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<E extends MAP KEY_VALUE_GENERIC_TYPE>
+public class SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<E extends MAP KEY_VALUE_GENERIC_TYPE>
-{
+{
-	BiFunction<KEY_TYPE[], VALUE_TYPE[], E> mapper;
+	BiFunction<KEY_TYPE[], VALUE_TYPE[], E> mapper;
-#if TYPE_BYTE
+#if TYPE_BYTE
-	KEY_TYPE[] keys = new KEY_TYPE[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)-2, (byte)-1, (byte)5, (byte)6};
+	KEY_TYPE[] keys = new KEY_TYPE[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)-2, (byte)-1, (byte)5, (byte)6};
-#else if TYPE_SHORT
+#else if TYPE_SHORT
-	KEY_TYPE[] keys = new KEY_TYPE[]{(short)0, (short)1, (short)2, (short)3, (short)4, (short)-2, (short)-1, (short)5, (short)6};
+	KEY_TYPE[] keys = new KEY_TYPE[]{(short)0, (short)1, (short)2, (short)3, (short)4, (short)-2, (short)-1, (short)5, (short)6};
-#else if TYPE_CHAR
+#else if TYPE_CHAR
-	KEY_TYPE[] keys = new KEY_TYPE[]{(char)0, (char)1, (char)2, (char)3, (char)4};
+	KEY_TYPE[] keys = new KEY_TYPE[]{(char)0, (char)1, (char)2, (char)3, (char)4};
-#else if TYPE_OBJECT
+#else if TYPE_OBJECT
-	KEY_TYPE[] keys;
+	KEY_TYPE[] keys;
-#else
+#else
-	KEY_TYPE[] keys = new KEY_TYPE[]{0, 1, 2, 3, 4, -2, -1, 5, 6};
+	KEY_TYPE[] keys = new KEY_TYPE[]{0, 1, 2, 3, 4, -2, -1, 5, 6};
-#endif
+#endif
-#if VALUE_BOOLEAN
+#if VALUE_BOOLEAN
-	VALUE_TYPE[] values = new VALUE_TYPE[]{true, true, true, false, true, false, true, false, true};
+	VALUE_TYPE[] values = new VALUE_TYPE[]{true, true, true, false, true, false, true, false, true};
-#else if VALUE_BYTE
+#else if VALUE_BYTE
-	VALUE_TYPE[] values = new VALUE_TYPE[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)-2, (byte)-1, (byte)5, (byte)6};
+	VALUE_TYPE[] values = new VALUE_TYPE[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)-2, (byte)-1, (byte)5, (byte)6};
-#else if VALUE_SHORT
+#else if VALUE_SHORT
-	VALUE_TYPE[] values = new VALUE_TYPE[]{(short)0, (short)1, (short)2, (short)3, (short)4, (short)-2, (short)-1, (short)5, (short)6};
+	VALUE_TYPE[] values = new VALUE_TYPE[]{(short)0, (short)1, (short)2, (short)3, (short)4, (short)-2, (short)-1, (short)5, (short)6};
-#else if VALUE_CHAR
+#else if VALUE_CHAR
-	VALUE_TYPE[] values = new VALUE_TYPE[]{(char)0, (char)1, (char)2, (char)3, (char)4};
+	VALUE_TYPE[] values = new VALUE_TYPE[]{(char)0, (char)1, (char)2, (char)3, (char)4};
-#else if VALUE_OBJECT
+#else if VALUE_OBJECT
-	VALUE_TYPE[] values;
+	VALUE_TYPE[] values;
-#else
+#else
-	VALUE_TYPE[] values = new VALUE_TYPE[]{0, 1, 2, 3, 4, -2, -1, 5, 6};
+	VALUE_TYPE[] values = new VALUE_TYPE[]{0, 1, 2, 3, 4, -2, -1, 5, 6};
-#endif
+#endif
-	
+	
-	public SIMPLE_MAP_TEST_GENERATOR(BiFunction<KEY_TYPE[], VALUE_TYPE[], E> mapper) {
+	public SIMPLE_MAP_TEST_GENERATOR(BiFunction<KEY_TYPE[], VALUE_TYPE[], E> mapper) {
-		this.mapper = mapper;
+		this.mapper = mapper;
-	}
+	}
-	
+	
-#if TYPE_OBJECT || TYPE_CHAR
+#if TYPE_OBJECT || TYPE_CHAR
-	public void setKeys(KEY_TYPE... keys) {
+	public void setKeys(KEY_TYPE... keys) {
-		this.keys = keys;
+		this.keys = keys;
-	}
+	}
-	
+	
-#endif
+#endif
-#if VALUE_OBJECT || VALUE_CHAR
+#if VALUE_OBJECT || VALUE_CHAR
-	public void setValues(VALUE_TYPE... values) {
+	public void setValues(VALUE_TYPE... values) {
-		this.values = values;
+		this.values = values;
-	}
+	}
-	
+	
-#endif
+#endif
-	public ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSamples() {
+	public ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSamples() {
-		return new ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE>(
+		return new ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE>(
-			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[0], values[0]),
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[0], values[0]),
-			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[1], values[1]),
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[1], values[1]),
-			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[2], values[2]),
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[2], values[2]),
-			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[3], values[3]),
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[3], values[3]),
-			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[4], values[4])
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[4], values[4])
-		);
+		);
-	}
+	}
-	
+	
-	public E create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements) {
+	public E create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements) {
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-		KEY_TYPE[] keys = (T[])ObjectArrays.newArray(getSamples().e0().ENTRY_KEY().getClass(), elements.length);
+		KEY_TYPE[] keys = (T[])ObjectArrays.newArray(getSamples().e0().ENTRY_KEY().getClass(), elements.length);
-#else
+#else
-		KEY_TYPE[] keys = NEW_KEY_ARRAY(elements.length);
+		KEY_TYPE[] keys = NEW_KEY_ARRAY(elements.length);
-#endif
+#endif
-#if VALUE_OBJECT
+#if VALUE_OBJECT
-		VALUE_TYPE[] values = (V[])ObjectArrays.newArray(getSamples().e0().ENTRY_VALUE().getClass(), elements.length);
+		VALUE_TYPE[] values = (V[])ObjectArrays.newArray(getSamples().e0().ENTRY_VALUE().getClass(), elements.length);
-#else
+#else
-		VALUE_TYPE[] values = NEW_VALUE_ARRAY(elements.length);
+		VALUE_TYPE[] values = NEW_VALUE_ARRAY(elements.length);
-#endif
+#endif
-		for(int i = 0;i<elements.length;i++) {
+		for(int i = 0;i<elements.length;i++) {
-			keys[i] = elements[i].ENTRY_KEY();
+			keys[i] = elements[i].ENTRY_KEY();
-			values[i] = elements[i].ENTRY_VALUE();
+			values[i] = elements[i].ENTRY_VALUE();
-		}
+		}
-		return mapper.apply(keys, values);
+		return mapper.apply(keys, values);
-	}
+	}
-	
+	
-	public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
+	public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
-		return insertionOrder;
+		return insertionOrder;
-	}
+	}
-	
+	
-	public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+	public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
-		return insertionOrder;
+		return insertionOrder;
-	}
+	}
-	
+	
-	public static class Maps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<MAP KEY_VALUE_GENERIC_TYPE> implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	public static class Maps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<MAP KEY_VALUE_GENERIC_TYPE> implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
-	{
+	{
-		public Maps(BiFunction<KEY_TYPE[], VALUE_TYPE[], MAP KEY_VALUE_GENERIC_TYPE> mapper) {
+		public Maps(BiFunction<KEY_TYPE[], VALUE_TYPE[], MAP KEY_VALUE_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-		}
+		}
-	}
+	}
-	
+	
-	public static class OrderedMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<ORDERED_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	public static class OrderedMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<ORDERED_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
-	{
+	{
-		public OrderedMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], ORDERED_MAP KEY_VALUE_GENERIC_TYPE> mapper) {
+		public OrderedMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], ORDERED_MAP KEY_VALUE_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-		}
+		}
-	}
+	}
-	
+	
-	public static class ConcurrentMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	public static class ConcurrentMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
-	{
+	{
-		Consumer<ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE>> sorter; 
+		Consumer<ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE>> sorter; 
-		
+		
-		public ConcurrentMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE> mapper, Consumer<ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE>> sorter) {
+		public ConcurrentMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE> mapper, Consumer<ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE>> sorter) {
-			super(mapper);
+			super(mapper);
-			this.sorter = sorter;
+			this.sorter = sorter;
-		}
+		}
-		
+		
-		public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
+		public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
-			ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> newList = new ObjectArrayList<>();
+			ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> newList = new ObjectArrayList<>();
-			for(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry : insertionOrder) {
+			for(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry : insertionOrder) {
-				newList.add(new ABSTRACT_MAP.BasicEntryKV_BRACES(entry.getKey(), entry.getValue()));
+				newList.add(new ABSTRACT_MAP.BasicEntryKV_BRACES(entry.getKey(), entry.getValue()));
-			}
+			}
-			order(newList);
+			order(newList);
-			insertionOrder.sort(new Comparator<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>() {
+			insertionOrder.sort(new Comparator<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>() {
-				@Override
+				@Override
-				public int compare(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> key, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> value) {
+				public int compare(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> key, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> value) {
-					return Integer.signum(indexOf(OBJ_TO_KEY(key.getKey())) - indexOf(OBJ_TO_KEY(value.getKey())));
+					return Integer.signum(indexOf(OBJ_TO_KEY(key.getKey())) - indexOf(OBJ_TO_KEY(value.getKey())));
-				}
+				}
-				
+				
-				protected int indexOf(KEY_TYPE key) {
+				protected int indexOf(KEY_TYPE key) {
-					for(int i = 0,m=newList.size();i<m;i++) {
+					for(int i = 0,m=newList.size();i<m;i++) {
-						if(KEY_EQUALS(newList.get(i).ENTRY_KEY(), key)) return i;
+						if(KEY_EQUALS(newList.get(i).ENTRY_KEY(), key)) return i;
-					}
+					}
-					throw new IllegalArgumentException("MAP.entry sorter was corrupting data");
+					throw new IllegalArgumentException("MAP.entry sorter was corrupting data");
-				}
+				}
-			});
+			});
-			return insertionOrder;
+			return insertionOrder;
-		}
+		}
-		
+		
-		public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+		public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
-			sorter.accept(insertionOrder);
+			sorter.accept(insertionOrder);
-			return insertionOrder;
+			return insertionOrder;
-		}
+		}
-	}
+	}
-	
+	
-	public static class SortedMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<SORTED_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	public static class SortedMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<SORTED_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
-	{
+	{
-		public SortedMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], SORTED_MAP KEY_VALUE_GENERIC_TYPE> mapper) {
+		public SortedMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], SORTED_MAP KEY_VALUE_GENERIC_TYPE> mapper) {
-			super(mapper);
+			super(mapper);
-#if TYPE_CHAR
+#if TYPE_CHAR
-			setKeys(new KEY_TYPE[]{'a', 'b', 'c', 'd', 'e', '_', '`', 'f', 'g'});
+			setKeys(new KEY_TYPE[]{'a', 'b', 'c', 'd', 'e', '_', '`', 'f', 'g'});
-#endif
+#endif
-#if VALUE_CHAR
+#if VALUE_CHAR
-			setValues(new VALUE_TYPE[]{'a', 'b', 'c', 'd', 'e', '_', '`', 'f', 'g'});
+			setValues(new VALUE_TYPE[]{'a', 'b', 'c', 'd', 'e', '_', '`', 'f', 'g'});
-#endif
+#endif
-
+
-		}
+		}
-		
+		
-		public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
+		public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryObjectComparator((Comparator<T>)Comparator.naturalOrder()));
+			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryObjectComparator((Comparator<T>)Comparator.naturalOrder()));
-#else
+#else
-			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryObjectComparator(CLASS_TYPE::compare));
+			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryObjectComparator(CLASS_TYPE::compare));
-#endif
+#endif
-			return insertionOrder;
+			return insertionOrder;
-		}
+		}
-		
+		
-		public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+		public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryComparator((Comparator<T>)Comparator.naturalOrder()));
+			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryComparator((Comparator<T>)Comparator.naturalOrder()));
-#else
+#else
-			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryComparator(CLASS_TYPE::compare));
+			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryComparator(CLASS_TYPE::compare));
-#endif
+#endif
-			return insertionOrder;
+			return insertionOrder;
-		}
+		}
-		
+		
-		@Override
+		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[5], values[5]); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[5], values[5]); }
-		@Override
+		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[6], values[6]); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[6], values[6]); }
-		@Override
+		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[7], values[7]); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[7], values[7]); }
-		@Override
+		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[8], values[8]); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[8], values[8]); }
-	}
+	}
-}
+}

src/builder/resources/speiger/assets/testers/templates/impl/maps/TestMap.template

@@ -1,92 +1,92 @@
-package speiger.src.testers.PACKAGE.impl.maps;
+package speiger.src.testers.PACKAGE.impl.maps;
-
+
-import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
+import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.maps.impl.misc.ARRAY_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.misc.ARRAY_MAP;
-import speiger.src.collections.objects.collections.ObjectIterator;
+import speiger.src.collections.objects.collections.ObjectIterator;
-import speiger.src.collections.objects.sets.AbstractObjectSet;
+import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectSet;
+import speiger.src.collections.objects.sets.ObjectSet;
-
+
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class SIMPLE_TEST_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE
+public class SIMPLE_TEST_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE
-{
+{
-	MAP KEY_VALUE_GENERIC_TYPE map;
+	MAP KEY_VALUE_GENERIC_TYPE map;
-	
+	
-	public SIMPLE_TEST_MAP(KEY_TYPE[] keys, VALUE_TYPE[] values) {
+	public SIMPLE_TEST_MAP(KEY_TYPE[] keys, VALUE_TYPE[] values) {
-		map = new ARRAY_MAPKV_BRACES(keys, values);
+		map = new ARRAY_MAPKV_BRACES(keys, values);
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE setDefaultReturnValue(VALUE_TYPE v) {
+	public ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE setDefaultReturnValue(VALUE_TYPE v) {
-		map.setDefaultReturnValue(v);
+		map.setDefaultReturnValue(v);
-		return this;
+		return this;
-	}
+	}
-	
+	
-	@Override
+	@Override
-	public VALUE_TYPE getDefaultReturnValue() { return map.getDefaultReturnValue(); }
+	public VALUE_TYPE getDefaultReturnValue() { return map.getDefaultReturnValue(); }
-	
+	
-	@Override
+	@Override
-	public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) { return map.put(key, value); }
+	public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) { return map.put(key, value); }
-	@Override
+	@Override
-	public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) { return map.putIfAbsent(key, value); }
+	public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) { return map.putIfAbsent(key, value); }
-#if VALUE_PRIMITIVES
+#if VALUE_PRIMITIVES
-	@Override
+	@Override
-	public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { return map.addTo(key, value); }
+	public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { return map.addTo(key, value); }
-	@Override
+	@Override
-	public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { return map.subFrom(key, value); }
+	public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { return map.subFrom(key, value); }
-#endif
+#endif
-	@Override
+	@Override
-	public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { return map.REMOVE_VALUE(key); }
+	public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { return map.REMOVE_VALUE(key); }
-	@Override
+	@Override
-	public VALUE_TYPE REMOVE_VALUEOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.REMOVE_VALUEOrDefault(key, defaultValue); }
+	public VALUE_TYPE REMOVE_VALUEOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.REMOVE_VALUEOrDefault(key, defaultValue); }
-#if !TYPE_OBJECT || !VALUE_OBJECT
+#if !TYPE_OBJECT || !VALUE_OBJECT
-	@Override
+	@Override
-	public boolean remove(KEY_TYPE key, VALUE_TYPE value) { return map.remove(key, value); }
+	public boolean remove(KEY_TYPE key, VALUE_TYPE value) { return map.remove(key, value); }
-#endif
+#endif
-	@Override
+	@Override
-	public CLASS_VALUE_TYPE remove(Object key) { return map.remove(key); }
+	public CLASS_VALUE_TYPE remove(Object key) { return map.remove(key); }
-	@Override
+	@Override
-	public boolean remove(Object key, Object value) { return map.remove(key, value); }
+	public boolean remove(Object key, Object value) { return map.remove(key, value); }
-	@Override
+	@Override
-	public VALUE_TYPE GET_VALUE(KEY_TYPE key) { return map.GET_VALUE(key); }
+	public VALUE_TYPE GET_VALUE(KEY_TYPE key) { return map.GET_VALUE(key); }
-#if TYPE_OBJECT && !VALUE_OBJECT
+#if TYPE_OBJECT && !VALUE_OBJECT
-	@Override
+	@Override
-	public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.getOrDefault(key, defaultValue); }
+	public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.getOrDefault(key, defaultValue); }
-#endif
+#endif
-	@Override
+	@Override
-	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
+	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
-		return new AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>() {
+		return new AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>() {
-			@Override
+			@Override
-			public ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
+			public ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
-				return new ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE>() {
+				return new ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE>() {
-					ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iter = map.ENTRY_SET().iterator();
+					ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iter = map.ENTRY_SET().iterator();
-					@Override
+					@Override
-					public boolean hasNext() {
+					public boolean hasNext() {
-						return iter.hasNext();
+						return iter.hasNext();
-					}
+					}
-					
+					
-					@Override
+					@Override
-					public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
+					public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
-						MAP.Entry KEY_VALUE_GENERIC_TYPE entry = iter.next();
+						MAP.Entry KEY_VALUE_GENERIC_TYPE entry = iter.next();
-						return new ABSTRACT_MAP.BasicEntry KEY_VALUE_GENERIC_TYPE(entry.ENTRY_KEY(), entry.ENTRY_VALUE()) {
+						return new ABSTRACT_MAP.BasicEntry KEY_VALUE_GENERIC_TYPE(entry.ENTRY_KEY(), entry.ENTRY_VALUE()) {
-							@Override
+							@Override
-							public VALUE_TYPE setValue(VALUE_TYPE value) {
+							public VALUE_TYPE setValue(VALUE_TYPE value) {
-								return entry.setValue(value);
+								return entry.setValue(value);
-							}
+							}
-						};
+						};
-					}
+					}
-					
+					
-					@Override
+					@Override
-					public void remove() {
+					public void remove() {
-						iter.remove();
+						iter.remove();
-					}
+					}
-				};
+				};
-			}
+			}
-			
+			
-			@Override
+			@Override
-			public int size() {
+			public int size() {
-				return map.size();
+				return map.size();
-			}
+			}
-		};
+		};
-	}
+	}
 }

src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractCollectionTester.template

@@ -1,28 +1,28 @@
-package speiger.src.testers.PACKAGE.tests.base;
+package speiger.src.testers.PACKAGE.tests.base;
-
+
-import org.junit.Ignore;
+import org.junit.Ignore;
-
+
-import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
-
+
-@Ignore
+@Ignore
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public class ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE extends ABSTRACT_CONTAINER_TESTER KKS_GENERIC_TYPE<COLLECTION KEY_CLASS_GENERIC_TYPE>
+public class ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE extends ABSTRACT_CONTAINER_TESTER KKS_GENERIC_TYPE<COLLECTION KEY_CLASS_GENERIC_TYPE>
-{
+{
-	protected COLLECTION KEY_GENERIC_TYPE collection;
+	protected COLLECTION KEY_GENERIC_TYPE collection;
-
+
-	@Override
+	@Override
-	protected COLLECTION KEY_GENERIC_TYPE actualContents() {
+	protected COLLECTION KEY_GENERIC_TYPE actualContents() {
-		return collection;
+		return collection;
-	}
+	}
-
+
-	@Override
+	@Override
-	protected COLLECTION KEY_GENERIC_TYPE resetContainer(COLLECTION KEY_GENERIC_TYPE newContents) {
+	protected COLLECTION KEY_GENERIC_TYPE resetContainer(COLLECTION KEY_GENERIC_TYPE newContents) {
-		collection = super.resetContainer(newContents);
+		collection = super.resetContainer(newContents);
-		return collection;
+		return collection;
-	}
+	}
-
+
-	protected void resetCollection() {
+	protected void resetCollection() {
-		resetContainer();
+		resetContainer();
-	}
+	}
-
+
-}
+}

src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractContainerTester.template

@@ -1,188 +1,188 @@
-package speiger.src.testers.PACKAGE.tests.base;
+package speiger.src.testers.PACKAGE.tests.base;
-
+
-import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.AbstractTester;
-import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
-import com.google.common.collect.testing.TestContainerGenerator;
+import com.google.common.collect.testing.TestContainerGenerator;
-import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.CollectionSize;
-import com.google.errorprone.annotations.OverridingMethodsMustInvokeSuper;
+import com.google.errorprone.annotations.OverridingMethodsMustInvokeSuper;
-
+
-import org.junit.Ignore;
+import org.junit.Ignore;
-
+
-import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
-import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
-import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
-import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
-import speiger.src.collections.PACKAGE.utils.LISTS;
+import speiger.src.collections.PACKAGE.utils.LISTS;
-import speiger.src.testers.PACKAGE.generators.TEST_COLLECTION_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_COLLECTION_GENERATOR;
-import speiger.src.testers.PACKAGE.utils.HELPERS;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
-import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
-import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
-
+
-@Ignore
+@Ignore
-@SuppressWarnings("javadoc")
+@SuppressWarnings("javadoc")
-public abstract class ABSTRACT_CONTAINER_TESTER KKS_GENERIC_TYPE<E> extends AbstractTester<OneSizeTestContainerGenerator<E, CLASS_TYPE>>
+public abstract class ABSTRACT_CONTAINER_TESTER KKS_GENERIC_TYPE<E> extends AbstractTester<OneSizeTestContainerGenerator<E, CLASS_TYPE>>
-{
+{
-	protected SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples;
+	protected SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples;
-	protected E container;
+	protected E container;
-	protected TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE primitiveGenerator;
+	protected TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE primitiveGenerator;
-	protected CollectionSize size;
+	protected CollectionSize size;
-
+
-	@Override
+	@Override
-	@OverridingMethodsMustInvokeSuper
+	@OverridingMethodsMustInvokeSuper
-	public void setUp() throws Exception {
+	public void setUp() throws Exception {
-		super.setUp();
+		super.setUp();
-		setupGenerator();
+		setupGenerator();
-	}
+	}
-	
+	
-	protected void setupGenerator() {
+	protected void setupGenerator() {
-		TestContainerGenerator<E, CLASS_TYPE> generator = getSubjectGenerator().getInnerGenerator();
+		TestContainerGenerator<E, CLASS_TYPE> generator = getSubjectGenerator().getInnerGenerator();
-		if (!(generator instanceof TEST_COLLECTION_GENERATOR)) throw new IllegalStateException("Test Generator Must extend TEST_COLLECTION_GENERATOR");
+		if (!(generator instanceof TEST_COLLECTION_GENERATOR)) throw new IllegalStateException("Test Generator Must extend TEST_COLLECTION_GENERATOR");
-		primitiveGenerator = (TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE) generator;
+		primitiveGenerator = (TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE) generator;
-		samples = primitiveGenerator.getSamples();
+		samples = primitiveGenerator.getSamples();
-		size = getSubjectGenerator().getCollectionSize();
+		size = getSubjectGenerator().getCollectionSize();
-		resetContainer();		
+		resetContainer();		
-	}
+	}
-
+
-	protected abstract COLLECTION KEY_GENERIC_TYPE actualContents();
+	protected abstract COLLECTION KEY_GENERIC_TYPE actualContents();
-
+
-	protected E resetContainer() {
+	protected E resetContainer() {
-		return resetContainer(createTestSubject());
+		return resetContainer(createTestSubject());
-	}
+	}
-
+
-	protected E resetContainer(E newValue) {
+	protected E resetContainer(E newValue) {
-		container = newValue;
+		container = newValue;
-		return container;
+		return container;
-	}
+	}
-
+
-	protected void expectContents(KEY_TYPE... elements) {
+	protected void expectContents(KEY_TYPE... elements) {
-		expectContents(ARRAY_LIST.wrap(elements));
+		expectContents(ARRAY_LIST.wrap(elements));
-	}
+	}
-
+
-	protected void expectContents(COLLECTION KEY_GENERIC_TYPE expected) {
+	protected void expectContents(COLLECTION KEY_GENERIC_TYPE expected) {
-		HELPERS.assertEqualIgnoringOrder(expected, actualContents());
+		HELPERS.assertEqualIgnoringOrder(expected, actualContents());
-	}
+	}
-
+
-	protected void expectUnchanged() {
+	protected void expectUnchanged() {
-		expectContents(getOrderedElements());
+		expectContents(getOrderedElements());
-	}
+	}
-
+
-	protected final void expectAdded(KEY_TYPE... elements) {
+	protected final void expectAdded(KEY_TYPE... elements) {
-		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(getSampleElements());
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(getSampleElements());
-		expected.addAll(elements);
+		expected.addAll(elements);
-		expectContents(expected);
+		expectContents(expected);
-	}
+	}
-
+
-	protected final void expectAddedIndex(int index, KEY_TYPE... elements) {
+	protected final void expectAddedIndex(int index, KEY_TYPE... elements) {
-		expectAdded(index, ARRAY_LIST.wrap(elements));
+		expectAdded(index, ARRAY_LIST.wrap(elements));
-	}
+	}
-
+
-	protected final void expectAdded(int index, COLLECTION KEY_GENERIC_TYPE elements) {
+	protected final void expectAdded(int index, COLLECTION KEY_GENERIC_TYPE elements) {
-		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(getSampleElements());
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(getSampleElements());
-		expected.addAll(index, elements);
+		expected.addAll(index, elements);
-		expectContents(expected);
+		expectContents(expected);
-	}
+	}
-
+
-	protected void expectMissing(KEY_TYPE... elements) {
+	protected void expectMissing(KEY_TYPE... elements) {
-		for (KEY_TYPE element : elements) {
+		for (KEY_TYPE element : elements) {
-			assertFalse("Should not contain " + element, actualContents().contains(element));
+			assertFalse("Should not contain " + element, actualContents().contains(element));
-		}
+		}
-	}
+	}
-
+
-	protected KEY_TYPE[] createSamplesArray() {
+	protected KEY_TYPE[] createSamplesArray() {
-		return getSampleElements().TO_ARRAY(NEW_KEY_ARRAY(getNumElements()));
+		return getSampleElements().TO_ARRAY(NEW_KEY_ARRAY(getNumElements()));
-	}
+	}
-
+
-	protected KEY_TYPE[] createOrderedArray() {
+	protected KEY_TYPE[] createOrderedArray() {
-		return getOrderedElements().TO_ARRAY(NEW_KEY_ARRAY(getNumElements()));
+		return getOrderedElements().TO_ARRAY(NEW_KEY_ARRAY(getNumElements()));
-	}
+	}
-
+
-	public static class ArrayWithDuplicate KEY_GENERIC_TYPE {
+	public static class ArrayWithDuplicate KEY_GENERIC_TYPE {
-		public final KEY_TYPE[] elements;
+		public final KEY_TYPE[] elements;
-		public final KEY_TYPE duplicate;
+		public final KEY_TYPE duplicate;
-
+
-		private ArrayWithDuplicate(KEY_TYPE[] elements, KEY_TYPE duplicate) {
+		private ArrayWithDuplicate(KEY_TYPE[] elements, KEY_TYPE duplicate) {
-			this.elements = elements;
+			this.elements = elements;
-			this.duplicate = duplicate;
+			this.duplicate = duplicate;
-		}
+		}
-	}
+	}
-
+
-	protected ArrayWithDuplicate KEY_GENERIC_TYPE createArrayWithDuplicateElement() {
+	protected ArrayWithDuplicate KEY_GENERIC_TYPE createArrayWithDuplicateElement() {
-		KEY_TYPE[] elements = createSamplesArray();
+		KEY_TYPE[] elements = createSamplesArray();
-		KEY_TYPE duplicate = elements[(elements.length / 2) - 1];
+		KEY_TYPE duplicate = elements[(elements.length / 2) - 1];
-		elements[(elements.length / 2) + 1] = duplicate;
+		elements[(elements.length / 2) + 1] = duplicate;
-		return new ArrayWithDuplicateBRACES(elements, duplicate);
+		return new ArrayWithDuplicateBRACES(elements, duplicate);
-	}
+	}
-
+
-	protected int getNumElements() {
+	protected int getNumElements() {
-		return size.getNumElements();
+		return size.getNumElements();
-	}
+	}
-
+
-	protected COLLECTION KEY_GENERIC_TYPE getSampleElements() {
+	protected COLLECTION KEY_GENERIC_TYPE getSampleElements() {
-		return getSampleElements(getNumElements());
+		return getSampleElements(getNumElements());
-	}
+	}
-
+
-	protected LIST KEY_GENERIC_TYPE getOrderedElements() {
+	protected LIST KEY_GENERIC_TYPE getOrderedElements() {
-		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
-		for (ITERATOR KEY_GENERIC_TYPE iter = primitiveGenerator.order(new ARRAY_LISTBRACES(getSampleElements())).iterator(); iter.hasNext();) {
+		for (ITERATOR KEY_GENERIC_TYPE iter = primitiveGenerator.order(new ARRAY_LISTBRACES(getSampleElements())).iterator(); iter.hasNext();) {
-			list.add(iter.NEXT());
+			list.add(iter.NEXT());
-		}
+		}
-		return LISTS.unmodifiable(list);
+		return LISTS.unmodifiable(list);
-	}
+	}
-	
+	
-#if TYPE_OBJECT
+#if TYPE_OBJECT
-	protected KEY_TYPE[] createDisjointArray() {
+	protected KEY_TYPE[] createDisjointArray() {
-		KEY_TYPE[] array = NEW_KEY_ARRAY(2);
+		KEY_TYPE[] array = NEW_KEY_ARRAY(2);
-		array[0] = e3();
+		array[0] = e3();
-		array[1] = e4();
+		array[1] = e4();
-		return array;
+		return array;
-	}
+	}
-#else
+#else
-	protected KEY_TYPE[] createDisjointArray() {
+	protected KEY_TYPE[] createDisjointArray() {
-		return new KEY_TYPE[]{e3(), e4()};
+		return new KEY_TYPE[]{e3(), e4()};
-	}
+	}
-	
+	
-#endif	
+#endif	
-	protected KEY_TYPE[] emptyArray() {
+	protected KEY_TYPE[] emptyArray() {
-		return NEW_KEY_ARRAY(0);
+		return NEW_KEY_ARRAY(0);
-	}
+	}
-	
+	
-	protected MINIMAL_COLLECTION KEY_GENERIC_TYPE createDisjointCollection() {
+	protected MINIMAL_COLLECTION KEY_GENERIC_TYPE createDisjointCollection() {
-		return MINIMAL_COLLECTION.of(e3(), e4());
+		return MINIMAL_COLLECTION.of(e3(), e4());
-	}
+	}
-	
+	
-	protected MINIMAL_COLLECTION KEY_GENERIC_TYPE emptyCollection() {
+	protected MINIMAL_COLLECTION KEY_GENERIC_TYPE emptyCollection() {
-		return MINIMAL_COLLECTION.of();
+		return MINIMAL_COLLECTION.of();
-	}
+	}
-	
+	
-	public KEY_TYPE[] createArray(KEY_TYPE...array) {
+	public KEY_TYPE[] createArray(KEY_TYPE...array) {
-		return array;
+		return array;
-	}
+	}
-	
+	
-	protected final KEY_TYPE e0() {
+	protected final KEY_TYPE e0() {
-		return samples.e0();
+		return samples.e0();
-	}
+	}
-
+
-	protected final KEY_TYPE e1() {
+	protected final KEY_TYPE e1() {
-		return samples.e1();
+		return samples.e1();
-	}
+	}
-
+
-	protected final KEY_TYPE e2() {
+	protected final KEY_TYPE e2() {
-		return samples.e2();
+		return samples.e2();
-	}
+	}
-
+
-	protected final KEY_TYPE e3() {
+	protected final KEY_TYPE e3() {
-		return samples.e3();
+		return samples.e3();
-	}
+	}
-
+
-	protected final KEY_TYPE e4() {
+	protected final KEY_TYPE e4() {
-		return samples.e4();
+		return samples.e4();
-	}
+	}
-
+
-	protected E createTestSubject() {
+	protected E createTestSubject() {
-		return (E)primitiveGenerator.create(getSampleElements(size.getNumElements()).TO_ARRAY(NEW_KEY_ARRAY(getNumElements())));
+		return (E)primitiveGenerator.create(getSampleElements(size.getNumElements()).TO_ARRAY(NEW_KEY_ARRAY(getNumElements())));
-	}
+	}
-
+
-	protected COLLECTION KEY_GENERIC_TYPE getSampleElements(int howMany) {
+	protected COLLECTION KEY_GENERIC_TYPE getSampleElements(int howMany) {
-		return new ARRAY_LISTBRACES(samples.asList().subList(0, howMany));
+		return new ARRAY_LISTBRACES(samples.asList().subList(0, howMany));
-	}
+	}
 }