diff --git a/EXTRAS.md b/EXTRAS.md index e656559..331795f 100644 --- a/EXTRAS.md +++ b/EXTRAS.md @@ -30,10 +30,13 @@ There is 3 layers of control inside of the ModuleSettings. 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". +Any Setting that isn't "Present" can be defined as "Enabled" or "Disabled" using the "Default" argument. +If "Default" is missing, then it will just default to "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. +Note: If a global Module setting is disabled but a dependency needs said Module, it will enable only the required classes. +If a Module type (Float-Collection as example) is specifically disabled, the Dependency Resolver will throw errors telling you whats wrong. How to compile the Code with the ModuleSettings enabled: ``` diff --git a/ModulSettings.json b/ModulSettings.json index 7c0c7c5..a045b18 100644 --- a/ModulSettings.json +++ b/ModulSettings.json @@ -1,46 +1,2625 @@ { + "Default": true, + "Async": true, "Base": true, + "Collection": true, "Function": true, - "Character": { - "Object": { - "Map": { + "List": true, + "Map": true, + "Pair": true, + "PriorityQueue": true, + "Set": true, + "Boolean": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { "Enabled": true, - "Implementations": true, - "HashMap": true + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true } }, "Collection": { "Enabled": true, - "Streams": true, - "Splititerators": true, "IArray": true, - "Strategy": false - } - }, - "Object": { - "Object": { - "Map": { - "Enabled": true, - "OrderedMap": true, - "Implementations": true, - "Wrappers": true, - "ImmutableMap": true, - "HashMap": true, - "LinkedHashMap": true - } + "Splititerators": true, + "Strategy": true, + "Streams": true }, - "Collection": { + "PriorityQueue": { "Enabled": true, - "Streams": true, - "Splititerators": true, - "IArray": true, - "Strategy": false + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true }, "List": { "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, "Implementations": true, - "Wrappers": true, - "ArrayList": true + "LinkedList": true, + "Wrappers": true + }, + "Async": { + "Enabled": true + } + }, + "Byte": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Collection": { + "Enabled": true, + "IArray": true, + "Splititerators": true, + "Strategy": true, + "Streams": true + }, + "PriorityQueue": { + "Enabled": true, + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true + }, + "List": { + "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, + "Implementations": true, + "LinkedList": true, + "Wrappers": true + }, + "Set": { + "Enabled": true, + "AVLTreeSet": true, + "ArraySet": true, + "CustomHashSet": true, + "HashSet": true, + "ImmutableSet": true, + "Implementations": true, + "LinkedCustomHashSet": true, + "LinkedHashSet": true, + "OrderedSet": true, + "RBTreeSet": true, + "SortedSet": true, + "Wrappers": true + }, + "Async": { + "Enabled": true + } + }, + "Short": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Collection": { + "Enabled": true, + "IArray": true, + "Splititerators": true, + "Strategy": true, + "Streams": true + }, + "PriorityQueue": { + "Enabled": true, + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true + }, + "List": { + "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, + "Implementations": true, + "LinkedList": true, + "Wrappers": true + }, + "Set": { + "Enabled": true, + "AVLTreeSet": true, + "ArraySet": true, + "CustomHashSet": true, + "HashSet": true, + "ImmutableSet": true, + "Implementations": true, + "LinkedCustomHashSet": true, + "LinkedHashSet": true, + "OrderedSet": true, + "RBTreeSet": true, + "SortedSet": true, + "Wrappers": true + }, + "Async": { + "Enabled": true + } + }, + "Character": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Collection": { + "Enabled": true, + "IArray": true, + "Splititerators": true, + "Strategy": true, + "Streams": true + }, + "PriorityQueue": { + "Enabled": true, + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true + }, + "List": { + "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, + "Implementations": true, + "LinkedList": true, + "Wrappers": true + }, + "Set": { + "Enabled": true, + "AVLTreeSet": true, + "ArraySet": true, + "CustomHashSet": true, + "HashSet": true, + "ImmutableSet": true, + "Implementations": true, + "LinkedCustomHashSet": true, + "LinkedHashSet": true, + "OrderedSet": true, + "RBTreeSet": true, + "SortedSet": true, + "Wrappers": true + }, + "Async": { + "Enabled": true + } + }, + "Integer": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Collection": { + "Enabled": true, + "IArray": true, + "Splititerators": true, + "Strategy": true, + "Streams": true + }, + "PriorityQueue": { + "Enabled": true, + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true + }, + "List": { + "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, + "Implementations": true, + "LinkedList": true, + "Wrappers": true + }, + "Set": { + "Enabled": true, + "AVLTreeSet": true, + "ArraySet": true, + "CustomHashSet": true, + "HashSet": true, + "ImmutableSet": true, + "Implementations": true, + "LinkedCustomHashSet": true, + "LinkedHashSet": true, + "OrderedSet": true, + "RBTreeSet": true, + "SortedSet": true, + "Wrappers": true + }, + "Async": { + "Enabled": true + } + }, + "Long": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Collection": { + "Enabled": true, + "IArray": true, + "Splititerators": true, + "Strategy": true, + "Streams": true + }, + "PriorityQueue": { + "Enabled": true, + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true + }, + "List": { + "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, + "Implementations": true, + "LinkedList": true, + "Wrappers": true + }, + "Set": { + "Enabled": true, + "AVLTreeSet": true, + "ArraySet": true, + "CustomHashSet": true, + "HashSet": true, + "ImmutableSet": true, + "Implementations": true, + "LinkedCustomHashSet": true, + "LinkedHashSet": true, + "OrderedSet": true, + "RBTreeSet": true, + "SortedSet": true, + "Wrappers": true + }, + "Async": { + "Enabled": true + } + }, + "Float": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Collection": { + "Enabled": true, + "IArray": true, + "Splititerators": true, + "Strategy": true, + "Streams": true + }, + "PriorityQueue": { + "Enabled": true, + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true + }, + "List": { + "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, + "Implementations": true, + "LinkedList": true, + "Wrappers": true + }, + "Set": { + "Enabled": true, + "AVLTreeSet": true, + "ArraySet": true, + "CustomHashSet": true, + "HashSet": true, + "ImmutableSet": true, + "Implementations": true, + "LinkedCustomHashSet": true, + "LinkedHashSet": true, + "OrderedSet": true, + "RBTreeSet": true, + "SortedSet": true, + "Wrappers": true + }, + "Async": { + "Enabled": true + } + }, + "Double": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Collection": { + "Enabled": true, + "IArray": true, + "Splititerators": true, + "Strategy": true, + "Streams": true + }, + "PriorityQueue": { + "Enabled": true, + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true + }, + "List": { + "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, + "Implementations": true, + "LinkedList": true, + "Wrappers": true + }, + "Set": { + "Enabled": true, + "AVLTreeSet": true, + "ArraySet": true, + "CustomHashSet": true, + "HashSet": true, + "ImmutableSet": true, + "Implementations": true, + "LinkedCustomHashSet": true, + "LinkedHashSet": true, + "OrderedSet": true, + "RBTreeSet": true, + "SortedSet": true, + "Wrappers": true + }, + "Async": { + "Enabled": true + } + }, + "Object": { + "Enabled": true, + "Base": { + "Enabled": true + }, + "Boolean": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Byte": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Short": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Character": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Integer": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Long": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Float": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Double": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Object": { + "Enabled": true, + "Function": { + "Enabled": true + }, + "Map": { + "Enabled": true, + "AVLTreeMap": true, + "ArrayMap": true, + "ConcurrentMap": true, + "CustomHashMap": true, + "EnumMap": true, + "HashMap": true, + "ImmutableMap": true, + "Implementations": true, + "LinkedCustomHashMap": true, + "LinkedEnumMap": true, + "LinkedHashMap": true, + "OrderedMap": true, + "RBTreeMap": true, + "SortedMap": true, + "Wrappers": true + }, + "Pair": { + "Enabled": true, + "Immutable": true, + "Mutable": true + } + }, + "Collection": { + "Enabled": true, + "IArray": true, + "Splititerators": true, + "Strategy": true, + "Streams": true + }, + "PriorityQueue": { + "Enabled": true, + "ArrayPrioQueue": true, + "Dequeue": true, + "FiFoQueue": true, + "HeapQueue": true, + "Implementations": true, + "Wrappers": true + }, + "List": { + "Enabled": true, + "ArrayList": true, + "CopyOnWriteList": true, + "ImmutableList": true, + "Implementations": true, + "LinkedList": true, + "Wrappers": true + }, + "Set": { + "Enabled": true, + "AVLTreeSet": true, + "ArraySet": true, + "CustomHashSet": true, + "HashSet": true, + "ImmutableSet": true, + "Implementations": true, + "LinkedCustomHashSet": true, + "LinkedHashSet": true, + "OrderedSet": true, + "RBTreeSet": true, + "SortedSet": true, + "Wrappers": true + }, + "Async": { + "Enabled": true } } } \ No newline at end of file diff --git a/src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java b/src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java index 4ca3b0b..ac4ab3f 100644 --- a/src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java +++ b/src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java @@ -133,7 +133,6 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor biPackages.forEach(modules.get(i)::init); } modules.forEach(BaseModule::cleanup); - manager.printModuleSettings(Arrays.asList(MapModule.INSTANCE)); } private void finishPackages() { @@ -214,7 +213,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor boolean force = flags.contains("force"); boolean tests = flags.contains("tests"); boolean forceTests = flags.contains("force-tests"); - boolean load = !flags.contains("load"); + 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); diff --git a/src/builder/java/speiger/src/builder/SettingsManager.java b/src/builder/java/speiger/src/builder/SettingsManager.java index 125ec4c..97cb1fa 100644 --- a/src/builder/java/speiger/src/builder/SettingsManager.java +++ b/src/builder/java/speiger/src/builder/SettingsManager.java @@ -5,37 +5,71 @@ import java.io.IOException; import java.io.OutputStreamWriter; import java.nio.file.Files; import java.nio.file.Paths; +import java.util.ArrayList; import java.util.LinkedHashSet; import java.util.List; +import java.util.Map; import java.util.Set; +import java.util.TreeMap; import java.util.TreeSet; +import com.google.gson.JsonElement; import com.google.gson.JsonObject; import com.google.gson.JsonParser; import com.google.gson.internal.Streams; import com.google.gson.stream.JsonWriter; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.IDependency.LoadingState; import speiger.src.builder.modules.BaseModule; @SuppressWarnings("javadoc") public class SettingsManager { boolean loaded; + Map parsedData = new TreeMap<>(); JsonObject data = new JsonObject(); Set moduleNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER); Set allDependencies = new LinkedHashSet<>(); public void resolve() { - boolean valid = true; - for(int i = 0;i<10000 && valid;i++) { - boolean result = false; - for(IDependency entry : allDependencies) { - result |= entry.resolveDependencies(); + if(!loaded) return; + Set roots = new LinkedHashSet<>(); + Set leafs = new LinkedHashSet<>(); + for(IDependency entry : allDependencies) { + if(entry.isRoot()) { + roots.add(entry); + } + if(entry.isLeaf()) { + leafs.add(entry); } - valid = result; } - if(valid) throw new RuntimeException("Couldn't resolve dependencies!"); + /** + * This has to be 2 iteration passes. + * Due to Key Value Pairs, first pass does all initials keys, and the second pass processes the values. + * May require more passes but extremely unlikely + */ + for(int i = 0;i<2;i++) { + for(ClassType keyType : ModulePackage.TYPE) { + for(ClassType valueType : ModulePackage.TYPE) { + for(IDependency entry : roots) { + entry.resolveRequirements(keyType, valueType); + } + } + } + } + + List errors = new ArrayList<>(); + for(ClassType keyType : ModulePackage.TYPE) { + for(ClassType valueType : ModulePackage.TYPE) { + for(IDependency entry : leafs) { + entry.validateDependency(errors::add, keyType, valueType); + } + } + } + if(errors.size() > 0) { + throw new IllegalStateException("Issues with dependencies found: "+String.join("\n", errors)); + } } public void addModule(BaseModule module) { @@ -45,7 +79,7 @@ public class SettingsManager for(ClassType valueType : ModulePackage.TYPE) { if(!module.isModuleValid(keyType, valueType)) continue; for(IDependency dependency : module.getDependencies(keyType, valueType)) { - dependency.load(data, keyType, valueType); + dependency.set(parsedData); allDependencies.add(dependency); } } @@ -55,7 +89,7 @@ public class SettingsManager for(ClassType keyType : ModulePackage.TYPE) { if(!module.isModuleValid(keyType, keyType)) continue; for(IDependency dependency : module.getDependencies(keyType, keyType)) { - dependency.load(data, keyType, keyType); + dependency.set(parsedData); allDependencies.add(dependency); } } @@ -72,7 +106,6 @@ public class SettingsManager for(IDependency dependency : module.getDependencies(keyType, valueType)) { String key = dependency.getName(); if(key != null) obj.addProperty(key, true); - dependency.setLoaded(); } addModule(keyType, valueType, true, moduleName, obj); } @@ -85,7 +118,6 @@ public class SettingsManager for(IDependency dependency : module.getDependencies(keyType, keyType)) { String key = dependency.getName(); if(key != null) obj.addProperty(key, true); - dependency.setLoaded(); } addModule(keyType, keyType, false, moduleName, obj); } @@ -102,7 +134,7 @@ public class SettingsManager JsonObject obj = new JsonObject(); for(IDependency dependency : module.getDependencies(keyType, valueType)) { String key = dependency.getName(); - if(key != null) obj.addProperty(key, dependency.getState(keyType, valueType).getJsonResult()); + if(key != null) obj.addProperty(key, dependency.isLoaded(keyType, valueType).getJsonResult()); } addModule(data, keyType, valueType, true, moduleName, obj); } @@ -114,7 +146,7 @@ public class SettingsManager JsonObject obj = new JsonObject(); for(IDependency dependency : module.getDependencies(keyType, keyType)) { String key = dependency.getName(); - if(key != null) obj.addProperty(key, dependency.getState(keyType, keyType).getJsonResult()); + if(key != null) obj.addProperty(key, dependency.isLoaded(keyType, keyType).getJsonResult()); } addModule(data, keyType, keyType, false, moduleName, obj); } @@ -135,6 +167,9 @@ public class SettingsManager try(BufferedReader reader = Files.newBufferedReader(Paths.get("ModulSettings.json"))) { data = JsonParser.parseReader(reader).getAsJsonObject(); loaded = true; + IDependency.flatten("", false, data, parsedData); + JsonElement element = data.get("Default"); + LoadingState.setOptionalResolver(LoadingState.of(element == null ? true : element.getAsBoolean())); } catch(Exception e) { e.printStackTrace(); } } diff --git a/src/builder/java/speiger/src/builder/dependencies/BaseDependency.java b/src/builder/java/speiger/src/builder/dependencies/BaseDependency.java new file mode 100644 index 0000000..fa9381a --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/BaseDependency.java @@ -0,0 +1,137 @@ +package speiger.src.builder.dependencies; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.StringJoiner; +import java.util.TreeSet; +import java.util.function.Consumer; + +import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.Requirements.Requirement; + +@SuppressWarnings("javadoc") +public abstract class BaseDependency implements IDependency { + protected static boolean FETCH_FAILURES = false; + protected static Set FAILURE_KEYS = new TreeSet<>(); + + protected final String name; + protected final boolean biType; + protected Map dependencies; + protected List children = new ArrayList<>(); + protected List requirements = new ArrayList<>(); + protected ClassType keyType; + protected ClassType valueType; + + public BaseDependency(String name, boolean biType) { + this.name = name; + this.biType = biType; + } + + @Override + public String toString() { + return name; + } + + @Override + public void set(Map dependency) { + dependencies = dependency; + } + + @Override + public IDependency addDependency(Requirement require) { + requirements.add(require); + require.dependency.addChild(this); + return this; + } + + @Override + public void addChild(IDependency child) { + children.add(child); + } + + @Override + public boolean isLeaf() { + return children.isEmpty(); + } + + @Override + public boolean isRoot() { + return requirements.isEmpty(); + } + + protected LoadingState getGlobalState() { + return dependencies.getOrDefault(name, LoadingState.OPTIONAL); + } + + @Override + public String getLocalStateKey(ClassType keyType, ClassType valueType) { + return (biType ? keyType.getClassPath()+"-"+valueType.getClassPath() : keyType.getClassPath())+"-"+name; + } + + protected LoadingState getLocalState(ClassType keyType, ClassType valueType) { + return dependencies.getOrDefault(getLocalStateKey(keyType, valueType), LoadingState.OPTIONAL); + } + + protected LoadingState getReqirementState(ClassType keyType, ClassType valueType) { + LoadingState state = requirements.isEmpty() ? LoadingState.REQUIRED : LoadingState.OPTIONAL; + for(int i = 0,m=requirements.size();i result, ClassType keyType, ClassType valueType) { + if(getLocalState(keyType, valueType) == LoadingState.REQUIRED) { + FETCH_FAILURES = true; + for(Requirement req : requirements) { + req.test(keyType, valueType); + } + FETCH_FAILURES = false; + if(FAILURE_KEYS.size() > 0) { + int size = FAILURE_KEYS.size(); + StringJoiner joiner = new StringJoiner("], [", "[", "]"); + FAILURE_KEYS.forEach(joiner::add); + FAILURE_KEYS.clear(); + String joins = size > 1 ? "["+joiner.toString()+"]" : joiner.toString(); + + result.accept("["+getLocalStateKey(keyType, valueType)+"] Requires "+joins+" but it specifically has been disabled!"); + } + + } + } + + @Override + public void set(ClassType key, ClassType value) { + this.keyType = key; + this.valueType = value; + } + + @Override + public boolean isEnabled() { + if(keyType == null || keyType == null) return false; + return isLoaded(keyType, valueType).getJsonResult(); + } + + @Override + public String getName() { + return name; + } +} diff --git a/src/builder/java/speiger/src/builder/dependencies/FunctionDependency.java b/src/builder/java/speiger/src/builder/dependencies/FunctionDependency.java new file mode 100644 index 0000000..b53fdff --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/FunctionDependency.java @@ -0,0 +1,29 @@ +package speiger.src.builder.dependencies; + +import speiger.src.builder.ClassType; + +@SuppressWarnings("javadoc") +public class FunctionDependency extends BaseDependency { + ModuleDependency owner; + + public FunctionDependency(ModuleDependency owner, String name) { + super(name, owner.biType); + this.owner = owner; + } + + @Override + public LoadingState isLoaded(ClassType key, ClassType value) { + if(dependencies == null) return LoadingState.REQUIRED; + LoadingState result = getLocalState(key, value); + if(FETCH_FAILURES && result == LoadingState.REJECTED) { + FAILURE_KEYS.add(getLocalStateKey(key, value)); + } + return result.resolveIfUndefined().merge(getReqirementState(key, value)); + } + + @Override + public String getLocalStateKey(ClassType keyType, ClassType valueType) { + return (biType ? keyType.getClassPath()+"-"+valueType.getClassPath() : keyType.getClassPath())+"-"+owner.getName()+"-"+name; + } + +} diff --git a/src/builder/java/speiger/src/builder/dependencies/IDependency.java b/src/builder/java/speiger/src/builder/dependencies/IDependency.java new file mode 100644 index 0000000..e28dc9b --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/IDependency.java @@ -0,0 +1,104 @@ +package speiger.src.builder.dependencies; + +import java.util.Map; +import java.util.Map.Entry; +import java.util.function.Consumer; + +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonPrimitive; + +import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.Requirements.Requirement; + +@SuppressWarnings("javadoc") +public interface IDependency { + + + public void set(Map dependency); + public void set(ClassType key, ClassType value); + public LoadingState isLoaded(ClassType key, ClassType value); + public String getLocalStateKey(ClassType keyType, ClassType valueType); + public boolean isEnabled(); + public boolean isLeaf(); + public boolean isRoot(); + + public String getName(); + public void validateDependency(Consumer result, ClassType keyType, ClassType valueType); + public void resolveRequirements(ClassType keyType, ClassType valueType); + + public void addChild(IDependency child); + public T addDependency(Requirement require); + public default T addKeyDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.KEY_TEST, Requirements.KEY_GETTER)); } + public default T addValueDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.VALUE_TEST, Requirements.VALUE_GETTER)); } + public default T addEntryDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.ENTRY_TEST, Requirements.ENTRY_GETTER)); } + public default T addTypeDependency(IDependency dependency, ClassType type) { return addDependency(new Requirement(dependency, Requirements.typedTest(type), Requirements.typedKey(type))); } + public default T addOptionalTypeDependency(IDependency dependency, ClassType type, boolean key) { return addDependency(new Requirement(dependency, Requirements.optionalTest(type, key), Requirements.optionalKey(type, key))); } + public default T addOptionalTypeDependency(ClassType type, boolean key) { return addDependency(new Requirement(this, Requirements.optionalTest(type, key), Requirements.optionalKey(type, key))); } + + + public static void flatten(String prefix, boolean applyMiddle, JsonObject object, Map result) { + if(applyMiddle) prefix+="-"; + for(Entry entry : object.entrySet()) { + String key = entry.getKey(); + JsonElement value = entry.getValue(); + if(value instanceof JsonPrimitive) { + String entryKey = prefix+key; + if("Enabled".equalsIgnoreCase(key)) { + entryKey = prefix.substring(0, prefix.length()-1); + } + result.put(entryKey, LoadingState.of(((JsonPrimitive)value).getAsBoolean())); + } + if(value instanceof JsonObject) { + flatten(prefix+key, true, (JsonObject)value, result); + } + } + } + + public static enum LoadingState { + OPTIONAL, + REQUIRED, + REJECTED; + + private static LoadingState RESOLVED = LoadingState.REQUIRED; + + public static LoadingState of(boolean value) { + return value ? REQUIRED : REJECTED; + } + + public LoadingState merge(LoadingState merge) { + return ordinal() > merge.ordinal() ? this : merge; + } + + public LoadingState replaceIfUndefined(LoadingState state) { + return this == OPTIONAL ? state : this; + } + + public LoadingState resolveIfUndefined() { + return this == OPTIONAL ? RESOLVED : this; + } + + public LoadingState mergeDown(LoadingState merge) { + if(merge == REJECTED || ordinal() > merge.ordinal()) { + return this; + } + return merge; + } + + public LoadingState mergeUp(LoadingState merge) { + if(merge == REQUIRED || ordinal() > merge.ordinal()) { + return this; + } + return merge; + } + + public static void setOptionalResolver(LoadingState state) { + RESOLVED = state; + } + + public boolean getJsonResult() { + LoadingState state = this == OPTIONAL ? RESOLVED : this; + return state == REQUIRED; + } + } +} diff --git a/src/builder/java/speiger/src/builder/dependencies/ModuleDependency.java b/src/builder/java/speiger/src/builder/dependencies/ModuleDependency.java new file mode 100644 index 0000000..20d39da --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/ModuleDependency.java @@ -0,0 +1,31 @@ +package speiger.src.builder.dependencies; + +import speiger.src.builder.ClassType; +import speiger.src.builder.modules.BaseModule; + +@SuppressWarnings("javadoc") +public class ModuleDependency extends BaseDependency { + BaseModule owner; + + public ModuleDependency(BaseModule owner, boolean biType) { + super(owner.getModuleName(), biType); + this.owner = owner; + } + + public FunctionDependency createDependency(String name) { + FunctionDependency result = new FunctionDependency(this, name); + if(biType) result.addEntryDependency(this); + else result.addKeyDependency(this); + return result; + } + + @Override + public LoadingState isLoaded(ClassType key, ClassType value) { + if(dependencies == null) return LoadingState.REQUIRED; + LoadingState result = getLocalState(key, value); + if(FETCH_FAILURES && result == LoadingState.REJECTED) { + FAILURE_KEYS.add(getLocalStateKey(key, value)); + } + return result.replaceIfUndefined(getGlobalState()).resolveIfUndefined().merge(getReqirementState(key, value)); + } +} diff --git a/src/builder/java/speiger/src/builder/dependencies/Requirements.java b/src/builder/java/speiger/src/builder/dependencies/Requirements.java new file mode 100644 index 0000000..9940340 --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/Requirements.java @@ -0,0 +1,68 @@ +package speiger.src.builder.dependencies; + +import java.util.function.Consumer; + +import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.IDependency.LoadingState; + +@SuppressWarnings("javadoc") +public class Requirements { + public static final RequirementTest KEY_TEST = (T, K, V) -> T.isLoaded(K, K); + public static final RequirementTest VALUE_TEST = (T, K, V) -> T.isLoaded(V, V); + public static final RequirementTest ENTRY_TEST = (T, K, V) -> T.isLoaded(K, V); + + public static RequirementTest typedTest(ClassType type) { + return (T, K, V) -> T.isLoaded(type, type); + } + + public static RequirementTest optionalTest(ClassType type, boolean key) { + return (T, K, V) -> (key ? K : V) != type ? T.isLoaded(type, type) : LoadingState.REQUIRED; + } + + public static final RequirementKey KEY_GETTER = (T, K, V) -> T.getLocalStateKey(K, K); + public static final RequirementKey VALUE_GETTER = (T, K, V) -> T.getLocalStateKey(V, V); + public static final RequirementKey ENTRY_GETTER = (T, K, V) -> T.getLocalStateKey(K, V); + + public static RequirementKey typedKey(ClassType type) { + return (T, K, V) -> T.getLocalStateKey(type, type); + } + + public static RequirementKey optionalKey(ClassType type, boolean key) { + return (T, K, V) -> (key ? K : V) != type ? T.getLocalStateKey(type, type) : ""; + } + + + + public interface RequirementTest { + public LoadingState test(IDependency test, ClassType keyType, ClassType valueType); + } + + public static interface RequirementKey { + public String key(IDependency test, ClassType keyType, ClassType valueType); + } + + public static interface RequirementResolver { + public void resolve(IDependency test, Consumer result, ClassType keyType, ClassType valueType); + } + + public static class Requirement { + IDependency dependency; + RequirementTest test; + RequirementKey key; + + public Requirement(IDependency dependency, RequirementTest test, RequirementKey key) { + this.dependency = dependency; + this.test = test; + this.key = key; + } + + public LoadingState test(ClassType keyType, ClassType valueType) { + return test.test(dependency, keyType, valueType); + } + + public String key(ClassType keyType, ClassType valueType) { + return key.key(dependency, keyType, valueType); + } + + } +} diff --git a/src/builder/java/speiger/src/builder/dependency/DependencyBase.java b/src/builder/java/speiger/src/builder/dependency/DependencyBase.java deleted file mode 100644 index 01562a3..0000000 --- a/src/builder/java/speiger/src/builder/dependency/DependencyBase.java +++ /dev/null @@ -1,49 +0,0 @@ -package speiger.src.builder.dependency; - -import java.util.ArrayList; -import java.util.List; - -import speiger.src.builder.ClassType; - -@SuppressWarnings("javadoc") -public abstract class DependencyBase implements IDependency { - protected List children = new ArrayList<>(); - protected List parents = new ArrayList<>(); - - public T addChild(T child) { - children.add(child); - child.addParent(this); - return child; - } - - public T addParent(DependencyBase parent) { - parents.add(parent); - return (T) this; - } - - public List getParents() { - return parents; - } - - public List getChildren() { - return children; - } - - protected LoadingState getChildState(ClassType keyType, ClassType valueType) { - LoadingState state = LoadingState.UNDEFINED; - for(IDependency child : children) { - if(state == LoadingState.LOADED) return LoadingState.LOADED; - state = state.mergeDown(child.getState(keyType, valueType)); - } - return state; - } - - protected LoadingState getParentState(ClassType keyType, ClassType valueType) { - LoadingState state = LoadingState.UNDEFINED; - for(IDependency parent : parents) { - if(state == LoadingState.UNLOADED) return LoadingState.UNLOADED; - state = state.mergeUp(parent.getState(keyType, valueType)); - } - return state; - } -} diff --git a/src/builder/java/speiger/src/builder/dependency/DependencyFunction.java b/src/builder/java/speiger/src/builder/dependency/DependencyFunction.java deleted file mode 100644 index 424dc2d..0000000 --- a/src/builder/java/speiger/src/builder/dependency/DependencyFunction.java +++ /dev/null @@ -1,131 +0,0 @@ -package speiger.src.builder.dependency; - -import java.util.Arrays; - -import com.google.gson.JsonObject; - -import speiger.src.builder.ClassType; - -@SuppressWarnings("javadoc") -public abstract class DependencyFunction extends DependencyBase { - protected DependencyModule owner; - - public DependencyFunction(DependencyModule owner) { - this.owner = owner; - } - - @Override - public boolean isEnabled() { - return getState(owner.owner.keyType(), owner.owner.valueType()) == LoadingState.LOADED; - } - - public abstract DependencyFunction createSubFunction(String function); - - public static class SingleFunction extends DependencyFunction { - LoadingState[] state = new LoadingState[ClassType.values().length]; - String functionName; - - public SingleFunction(DependencyModule owner, String functionName) { - super(owner); - this.functionName = functionName; - Arrays.fill(state, LoadingState.UNDEFINED); - } - - @Override - public DependencyFunction createSubFunction(String function) { - return addChild(new SingleFunction(owner, function)); - } - - @Override - public void load(JsonObject obj, ClassType keyType, ClassType valueType) { - state[keyType.ordinal()] = owner.isFunctionLoaded(obj, keyType, valueType, functionName); - } - - @Override - public LoadingState getState(ClassType keyType, ClassType valueType) { - return state[keyType.ordinal()]; - } - - @Override - public boolean resolveDependencies() { - boolean returnType = false; - for(ClassType type : ClassType.values()) { - LoadingState state = this.state[type.ordinal()]; - if(state == LoadingState.UNLOADED) continue; - state = state.merge(getChildState(type, type)).merge(getParentState(type, type)); - if(state != this.state[type.ordinal()]) { - this.state[type.ordinal()] = state; - returnType = true; - } - } - return returnType; - } - - @Override - public String getName() { - return functionName; - } - - @Override - public void setLoaded() { - Arrays.fill(state, LoadingState.LOADED); - } - } - - public static class BiTypeFunction extends DependencyFunction { - LoadingState[][] state = new LoadingState[ClassType.values().length][ClassType.values().length]; - String functionName; - - BiTypeFunction(DependencyModule owner, String functionName) { - super(owner); - this.functionName = functionName; - for(int i = 0;i merge.ordinal() ? this : merge; - } - - public LoadingState replaceIfDefined(LoadingState state) { - return state == UNDEFINED ? this : state; - } - - public LoadingState mergeDown(LoadingState merge) { - if(merge == UNLOADED || ordinal() > merge.ordinal()) { - return this; - } - return merge; - } - - public LoadingState mergeUp(LoadingState merge) { - if(merge == LOADED || ordinal() > merge.ordinal()) { - return this; - } - return merge; - } - - public boolean getJsonResult() { - return this == LOADED; - } - } -} diff --git a/src/builder/java/speiger/src/builder/modules/AsyncModule.java b/src/builder/java/speiger/src/builder/modules/AsyncModule.java index 82659ae..832b314 100644 --- a/src/builder/java/speiger/src/builder/modules/AsyncModule.java +++ b/src/builder/java/speiger/src/builder/modules/AsyncModule.java @@ -4,16 +4,14 @@ import java.util.Arrays; import java.util.List; import speiger.src.builder.ClassType; -import speiger.src.builder.dependency.DependencyModule; -import speiger.src.builder.dependency.DependencyModule.SingleTypeModule; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class AsyncModule extends BaseModule { public static final BaseModule INSTANCE = new AsyncModule(); - public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE)); - + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(JavaModule.MODULE); @Override public String getModuleName() { return "Async"; } @@ -29,7 +27,7 @@ public class AsyncModule extends BaseModule public List getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE); } @Override protected void loadBlockades() { - if(MODULE.isEnabled()) { + if(!MODULE.isEnabled()) { addBlockedFiles("AsyncBuilder", "Task"); } } diff --git a/src/builder/java/speiger/src/builder/modules/BaseModule.java b/src/builder/java/speiger/src/builder/modules/BaseModule.java index 023c7fd..33ea237 100644 --- a/src/builder/java/speiger/src/builder/modules/BaseModule.java +++ b/src/builder/java/speiger/src/builder/modules/BaseModule.java @@ -9,7 +9,7 @@ import speiger.src.builder.ClassType; import speiger.src.builder.ModulePackage; import speiger.src.builder.RequiredType; import speiger.src.builder.SettingsManager; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.IDependency; import speiger.src.builder.mappers.ArgumentMapper; import speiger.src.builder.mappers.InjectMapper; import speiger.src.builder.mappers.LineMapper; @@ -32,6 +32,9 @@ public abstract class BaseModule this.entry = entry; keyType = entry.getKeyType(); valueType = entry.getValueType(); + for(IDependency dependency : getDependencies(keyType, valueType)) { + dependency.set(keyType, valueType); + } loadVariables(); loadClasses(); loadTestClasses(); diff --git a/src/builder/java/speiger/src/builder/modules/CollectionModule.java b/src/builder/java/speiger/src/builder/modules/CollectionModule.java index 4f84334..e1d1990 100644 --- a/src/builder/java/speiger/src/builder/modules/CollectionModule.java +++ b/src/builder/java/speiger/src/builder/modules/CollectionModule.java @@ -4,20 +4,23 @@ import java.util.Arrays; import java.util.List; import speiger.src.builder.ClassType; -import speiger.src.builder.dependency.DependencyFunction; -import speiger.src.builder.dependency.DependencyModule; -import speiger.src.builder.dependency.DependencyModule.SingleTypeModule; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class CollectionModule extends BaseModule { public static final BaseModule INSTANCE = new CollectionModule(); - public static final DependencyModule MODULE = JavaModule.MODULE.addChild(new SingleTypeModule(INSTANCE)); - public static final DependencyFunction STREAMS = MODULE.createFunction("Streams"); - public static final DependencyFunction SPLIT_ITERATORS = MODULE.createFunction("Splititerators"); - public static final DependencyFunction IARRAY = MODULE.createFunction("IArray"); - public static final DependencyFunction STRATEGY = MODULE.createFunction("Strategy"); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false) + .addKeyDependency(FunctionModule.MODULE) + .addOptionalTypeDependency(FunctionModule.MODULE, ClassType.OBJECT, true) + .addOptionalTypeDependency(FunctionModule.MODULE, ClassType.INT, true) + .addOptionalTypeDependency(ClassType.OBJECT, true); + public static final FunctionDependency STREAMS = MODULE.createDependency("Streams"); + public static final FunctionDependency SPLIT_ITERATORS = MODULE.createDependency("Splititerators").addKeyDependency(STREAMS); + public static final FunctionDependency IARRAY = MODULE.createDependency("IArray"); + public static final FunctionDependency STRATEGY = MODULE.createDependency("Strategy"); @Override public String getModuleName() { return "Collection"; } diff --git a/src/builder/java/speiger/src/builder/modules/FunctionModule.java b/src/builder/java/speiger/src/builder/modules/FunctionModule.java index 312cdc1..42ce610 100644 --- a/src/builder/java/speiger/src/builder/modules/FunctionModule.java +++ b/src/builder/java/speiger/src/builder/modules/FunctionModule.java @@ -5,15 +5,14 @@ import java.util.List; import speiger.src.builder.ClassType; import speiger.src.builder.RequiredType; -import speiger.src.builder.dependency.DependencyModule; -import speiger.src.builder.dependency.IDependency; -import speiger.src.builder.dependency.DependencyModule.BiTypeModule; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class FunctionModule extends BaseModule { public static final BaseModule INSTANCE = new FunctionModule(); - public static final DependencyModule MODULE = new BiTypeModule(INSTANCE); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(JavaModule.MODULE); @Override public String getModuleName() { return "Function"; } @@ -35,6 +34,7 @@ public class FunctionModule extends BaseModule protected void loadBlockades() { if(keyType.isObject()) addBlockedFiles("Consumer", "Comparator"); + if(!MODULE.isEnabled()) addBlockedFiles("Consumer", "BiConsumer", "Comparator", "Supplier", "Function", "UnaryOperator"); } @Override diff --git a/src/builder/java/speiger/src/builder/modules/JavaModule.java b/src/builder/java/speiger/src/builder/modules/JavaModule.java index 427bad6..e843c95 100644 --- a/src/builder/java/speiger/src/builder/modules/JavaModule.java +++ b/src/builder/java/speiger/src/builder/modules/JavaModule.java @@ -4,15 +4,14 @@ import java.util.Arrays; import java.util.List; import speiger.src.builder.ClassType; -import speiger.src.builder.dependency.DependencyBase; -import speiger.src.builder.dependency.IDependency; -import speiger.src.builder.dependency.DependencyModule.SingleTypeModule; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class JavaModule extends BaseModule { public static final BaseModule INSTANCE = new JavaModule(); - public static final DependencyBase MODULE = new SingleTypeModule(INSTANCE); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false); @Override public String getModuleName() { return "Base"; } diff --git a/src/builder/java/speiger/src/builder/modules/ListModule.java b/src/builder/java/speiger/src/builder/modules/ListModule.java index 40925a4..e52b688 100644 --- a/src/builder/java/speiger/src/builder/modules/ListModule.java +++ b/src/builder/java/speiger/src/builder/modules/ListModule.java @@ -4,23 +4,22 @@ import java.util.Arrays; import java.util.List; import speiger.src.builder.ClassType; -import speiger.src.builder.dependency.DependencyFunction; -import speiger.src.builder.dependency.DependencyModule; -import speiger.src.builder.dependency.DependencyModule.SingleTypeModule; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class ListModule extends BaseModule { public static final BaseModule INSTANCE = new ListModule(); - public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE)); - public static final DependencyFunction IMPLEMENTATION = MODULE.createFunction("Implementations"); - public static final DependencyFunction WRAPPERS = MODULE.createFunction("Wrappers"); - public static final DependencyFunction ARRAY_LIST = IMPLEMENTATION.createSubFunction("ArrayList"); - public static final DependencyFunction LINKED_LIST = IMPLEMENTATION.createSubFunction("LinkedList"); - public static final DependencyFunction IMMUTABLE_LIST = IMPLEMENTATION.createSubFunction("ImmutableList"); - public static final DependencyFunction COPY_ON_WRITE_LIST = IMPLEMENTATION.createSubFunction("CopyOnWriteList"); - + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE).addKeyDependency(CollectionModule.SPLIT_ITERATORS); + public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations"); + public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers"); + public static final FunctionDependency ARRAY_LIST = MODULE.createDependency("ArrayList").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency LINKED_LIST = MODULE.createDependency("LinkedList").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency IMMUTABLE_LIST = MODULE.createDependency("ImmutableList").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency COPY_ON_WRITE_LIST = MODULE.createDependency("CopyOnWriteList").addKeyDependency(IMPLEMENTATION); + @Override public String getModuleName() { return "List"; } @Override diff --git a/src/builder/java/speiger/src/builder/modules/MapModule.java b/src/builder/java/speiger/src/builder/modules/MapModule.java index 4439a5b..5dfc47c 100644 --- a/src/builder/java/speiger/src/builder/modules/MapModule.java +++ b/src/builder/java/speiger/src/builder/modules/MapModule.java @@ -1,40 +1,44 @@ package speiger.src.builder.modules; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import speiger.src.builder.ClassType; -import speiger.src.builder.dependency.DependencyFunction; -import speiger.src.builder.dependency.DependencyModule; -import speiger.src.builder.dependency.DependencyModule.BiTypeModule; -import speiger.src.builder.dependency.DependencyType; -import speiger.src.builder.dependency.DependencyValue; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class MapModule extends BaseModule { public static final BaseModule INSTANCE = new MapModule(); - public static final DependencyModule MODULE = make(new BiTypeModule(INSTANCE), T -> { - CollectionModule.MODULE.addChild(new DependencyValue(T)); - CollectionModule.MODULE.addChild(new DependencyType(T, ClassType.OBJECT)); - SetModule.MODULE.addChild(T); - }); - public static final DependencyFunction WRAPPERS = MODULE.createFunction("Wrappers"); - public static final DependencyFunction IMPLEMENTATION = MODULE.createFunction("Implementations"); - public static final DependencyFunction ORDERED_MAP = MODULE.createFunction("OrderedMap"); - public static final DependencyFunction SORTED_MAP = MODULE.createFunction("SortedMap"); - public static final DependencyFunction ARRAY_MAP = ORDERED_MAP.addChild(IMPLEMENTATION.createSubFunction("ArrayMap")); - public static final DependencyFunction IMMUTABLE_MAP = IMPLEMENTATION.createSubFunction("ImmutableMap"); - public static final DependencyFunction HASH_MAP = IMPLEMENTATION.createSubFunction("HashMap"); - public static final DependencyFunction LINKED_MAP = HASH_MAP.addChild(ORDERED_MAP.addChild(IMPLEMENTATION.createSubFunction("LinkedHashMap"))); - public static final DependencyFunction CUSTOM_MAP = IMPLEMENTATION.createSubFunction("CustomHashMap"); - public static final DependencyFunction LINKED_CUSTOM_MAP = CUSTOM_MAP.addChild(ORDERED_MAP.addChild(IMPLEMENTATION.createSubFunction("LinkedCustomHashMap"))); - public static final DependencyFunction ENUM_MAP = IMPLEMENTATION.createSubFunction("EnumMap"); - public static final DependencyFunction LINKED_ENUM_MAP = ENUM_MAP.addChild(ORDERED_MAP.addChild(IMPLEMENTATION.createSubFunction("LinkedEnumMap"))); - public static final DependencyFunction CONCURRENT_MAP = IMPLEMENTATION.createSubFunction("ConcurrentMap"); - public static final DependencyFunction AVL_TREE_MAP = SORTED_MAP.addChild(IMPLEMENTATION.createSubFunction("AVLTreeMap")); - public static final DependencyFunction RB_TREE_MAP = SORTED_MAP.addChild(IMPLEMENTATION.createSubFunction("RBTreeMap")); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, true) + .addKeyDependency(SetModule.MODULE) + .addValueDependency(CollectionModule.MODULE) + .addEntryDependency(SetModule.MODULE) + .addTypeDependency(SetModule.MODULE, ClassType.OBJECT); + public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations"); + public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers").addKeyDependency(SetModule.WRAPPERS).addOptionalTypeDependency(SetModule.WRAPPERS, ClassType.OBJECT, true); + + public static final FunctionDependency ORDERED_MAP = MODULE.createDependency("OrderedMap").addKeyDependency(SetModule.ORDERED_SET).addOptionalTypeDependency(SetModule.ORDERED_SET, ClassType.OBJECT, true); + public static final FunctionDependency SORTED_MAP = MODULE.createDependency("SortedMap").addKeyDependency(SetModule.SORTED_SET).addOptionalTypeDependency(SetModule.SORTED_SET, ClassType.OBJECT, true); + + public static final FunctionDependency ARRAY_MAP = MODULE.createDependency("ArrayMap").addEntryDependency(ORDERED_MAP).addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency IMMUTABLE_MAP = MODULE.createDependency("ImmutableMap").addEntryDependency(IMPLEMENTATION); + + public static final FunctionDependency HASH_MAP = MODULE.createDependency("HashMap").addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency LINKED_MAP = MODULE.createDependency("LinkedHashMap").addEntryDependency(HASH_MAP).addEntryDependency(ORDERED_MAP); + + public static final FunctionDependency CUSTOM_MAP = MODULE.createDependency("CustomHashMap").addEntryDependency(IMPLEMENTATION).addKeyDependency(CollectionModule.STRATEGY); + public static final FunctionDependency LINKED_CUSTOM_MAP = MODULE.createDependency("LinkedCustomHashMap").addEntryDependency(CUSTOM_MAP).addEntryDependency(ORDERED_MAP); + + public static final FunctionDependency ENUM_MAP = MODULE.createDependency("EnumMap").addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency LINKED_ENUM_MAP = MODULE.createDependency("LinkedEnumMap").addEntryDependency(ENUM_MAP).addEntryDependency(ORDERED_MAP); + + public static final FunctionDependency CONCURRENT_MAP = MODULE.createDependency("ConcurrentMap").addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency AVL_TREE_MAP = MODULE.createDependency("AVLTreeMap").addEntryDependency(SORTED_MAP).addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency RB_TREE_MAP = MODULE.createDependency("RBTreeMap").addEntryDependency(SORTED_MAP).addEntryDependency(IMPLEMENTATION); @Override public String getModuleName() { return "Map"; } @@ -45,7 +49,11 @@ public class MapModule extends BaseModule @Override public boolean isModuleValid(ClassType keyType, ClassType valueType) { return keyType != ClassType.BOOLEAN; } @Override - public List getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, ORDERED_MAP, SORTED_MAP, IMPLEMENTATION, WRAPPERS, ARRAY_MAP, IMMUTABLE_MAP, HASH_MAP, LINKED_MAP, CUSTOM_MAP, LINKED_CUSTOM_MAP, ENUM_MAP, LINKED_ENUM_MAP, CONCURRENT_MAP, AVL_TREE_MAP, RB_TREE_MAP); } + public List getDependencies(ClassType keyType, ClassType valueType) { + List dependencies = new ArrayList<>(Arrays.asList(MODULE, ORDERED_MAP, SORTED_MAP, IMPLEMENTATION, WRAPPERS, ARRAY_MAP, IMMUTABLE_MAP, HASH_MAP, LINKED_MAP, CUSTOM_MAP, LINKED_CUSTOM_MAP, CONCURRENT_MAP, AVL_TREE_MAP, RB_TREE_MAP)); + if(keyType == ClassType.OBJECT) dependencies.addAll(Arrays.asList(ENUM_MAP, LINKED_ENUM_MAP)); + return dependencies; + } @Override protected void loadFlags() @@ -79,7 +87,7 @@ public class MapModule extends BaseModule if(!ORDERED_MAP.isEnabled()) addBlockedFiles("OrderedMap"); if(!HASH_MAP.isEnabled()) addBlockedFiles("OpenHashMap"); if(!LINKED_MAP.isEnabled()) addBlockedFiles("LinkedOpenHashMap"); - if(CUSTOM_MAP.isEnabled()) addBlockedFiles("OpenCustomHashMap"); + if(!CUSTOM_MAP.isEnabled()) addBlockedFiles("OpenCustomHashMap"); if(!LINKED_CUSTOM_MAP.isEnabled()) addBlockedFiles("LinkedOpenCustomHashMap"); if(!ENUM_MAP.isEnabled()) addBlockedFiles("EnumMap"); if(!LINKED_ENUM_MAP.isEnabled()) addBlockedFiles("LinkedEnumMap"); diff --git a/src/builder/java/speiger/src/builder/modules/PairModule.java b/src/builder/java/speiger/src/builder/modules/PairModule.java index e4286c5..473fa40 100644 --- a/src/builder/java/speiger/src/builder/modules/PairModule.java +++ b/src/builder/java/speiger/src/builder/modules/PairModule.java @@ -4,18 +4,22 @@ import java.util.Arrays; import java.util.List; import speiger.src.builder.ClassType; -import speiger.src.builder.dependency.DependencyFunction; -import speiger.src.builder.dependency.DependencyModule; -import speiger.src.builder.dependency.DependencyModule.BiTypeModule; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class PairModule extends BaseModule { public static final BaseModule INSTANCE = new PairModule(); - public static final DependencyModule MODULE = new BiTypeModule(INSTANCE); - public static final DependencyFunction IMMUTABLE = MODULE.createFunction("Immutable"); - public static final DependencyFunction MUTABLE = MODULE.createFunction("Mutable"); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, true).addKeyDependency(JavaModule.MODULE); + public static final FunctionDependency IMMUTABLE = MODULE.createDependency("Immutable"); + public static final FunctionDependency MUTABLE = MODULE.createDependency("Mutable"); + + +// public static final DependencyModule MODULE = new BiTypeModule(INSTANCE); +// public static final DependencyFunction IMMUTABLE = MODULE.createFunction("Immutable"); +// public static final DependencyFunction MUTABLE = MODULE.createFunction("Mutable"); @Override public String getModuleName() { return "Pair"; } diff --git a/src/builder/java/speiger/src/builder/modules/PrioQueueModule.java b/src/builder/java/speiger/src/builder/modules/PrioQueueModule.java index 2a6f131..5489693 100644 --- a/src/builder/java/speiger/src/builder/modules/PrioQueueModule.java +++ b/src/builder/java/speiger/src/builder/modules/PrioQueueModule.java @@ -4,22 +4,23 @@ import java.util.Arrays; import java.util.List; import speiger.src.builder.ClassType; -import speiger.src.builder.dependency.DependencyFunction; -import speiger.src.builder.dependency.DependencyModule; -import speiger.src.builder.dependency.DependencyModule.SingleTypeModule; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class PrioQueueModule extends BaseModule { public static final BaseModule INSTANCE = new PrioQueueModule(); - public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE)); - public static final DependencyFunction IMPLEMENTATION = MODULE.createFunction("Implementations"); - public static final DependencyFunction WRAPPERS = MODULE.createFunction("Wrappers"); - public static final DependencyFunction DEQUEUE = MODULE.createFunction("Dequeue"); - public static final DependencyFunction FIFO_QUEUE = DEQUEUE.addChild(IMPLEMENTATION.createSubFunction("FiFoQueue")); - public static final DependencyFunction HEAP_QUEUE = IMPLEMENTATION.createSubFunction("HeapQueue"); - public static final DependencyFunction ARRAY_PRIO_QUEUE = IMPLEMENTATION.createSubFunction("ArrayPrioQueue"); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE); + public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations"); + public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers"); + public static final FunctionDependency DEQUEUE = MODULE.createDependency("Dequeue"); + + public static final FunctionDependency FIFO_QUEUE = MODULE.createDependency("FiFoQueue").addKeyDependency(DEQUEUE).addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency HEAP_QUEUE = MODULE.createDependency("HeapQueue").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency ARRAY_PRIO_QUEUE = MODULE.createDependency("ArrayPrioQueue").addKeyDependency(IMPLEMENTATION); + @Override public String getModuleName() { return "PriorityQueue"; } diff --git a/src/builder/java/speiger/src/builder/modules/SetModule.java b/src/builder/java/speiger/src/builder/modules/SetModule.java index 82c5b3b..098a63c 100644 --- a/src/builder/java/speiger/src/builder/modules/SetModule.java +++ b/src/builder/java/speiger/src/builder/modules/SetModule.java @@ -4,28 +4,27 @@ import java.util.Arrays; import java.util.List; import speiger.src.builder.ClassType; -import speiger.src.builder.dependency.DependencyFunction; -import speiger.src.builder.dependency.DependencyModule; -import speiger.src.builder.dependency.DependencyModule.SingleTypeModule; -import speiger.src.builder.dependency.IDependency; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class SetModule extends BaseModule { public static final BaseModule INSTANCE = new SetModule(); - public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE)); - public static final DependencyFunction WRAPPERS = MODULE.createFunction("Wrappers"); - public static final DependencyFunction IMPLEMENTATION = MODULE.createFunction("Implementations"); - public static final DependencyFunction ORDERED_SET = MODULE.createFunction("OrderedSet"); - public static final DependencyFunction SORTED_SET = MODULE.createFunction("SortedSet"); - public static final DependencyFunction ARRAY_SET = ORDERED_SET.addChild(IMPLEMENTATION.createSubFunction("ArraySet")); - public static final DependencyFunction IMMUTABLE_SET = IMPLEMENTATION.createSubFunction("ImmutableSet"); - public static final DependencyFunction HASH_SET = IMPLEMENTATION.createSubFunction("HashSet"); - public static final DependencyFunction LINKED_SET = HASH_SET.addChild(ORDERED_SET.addChild(IMPLEMENTATION.createSubFunction("LinkedHashSet"))); - public static final DependencyFunction CUSTOM_SET = IMPLEMENTATION.createSubFunction("CustomHashSet"); - public static final DependencyFunction LINKED_CUSTOM_SET = CUSTOM_SET.addChild(ORDERED_SET.addChild(IMPLEMENTATION.createSubFunction("LinkedCustomHashSet"))); - public static final DependencyFunction AVL_TREE_SET = SORTED_SET.addChild(IMPLEMENTATION.createSubFunction("AVLTreeSet")); - public static final DependencyFunction RB_TREE_SET = SORTED_SET.addChild(IMPLEMENTATION.createSubFunction("RBTreeSet")); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE).addKeyDependency(CollectionModule.SPLIT_ITERATORS); + public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations"); + public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers"); + public static final FunctionDependency ORDERED_SET = MODULE.createDependency("OrderedSet"); + public static final FunctionDependency SORTED_SET = MODULE.createDependency("SortedSet"); + public static final FunctionDependency ARRAY_SET = MODULE.createDependency("ArraySet").addKeyDependency(ORDERED_SET).addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency IMMUTABLE_SET = MODULE.createDependency("ImmutableSet").addKeyDependency(ORDERED_SET).addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency HASH_SET = MODULE.createDependency("HashSet").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency LINKED_SET = MODULE.createDependency("LinkedHashSet").addKeyDependency(ORDERED_SET).addKeyDependency(HASH_SET); + public static final FunctionDependency CUSTOM_SET = MODULE.createDependency("CustomHashSet").addKeyDependency(IMPLEMENTATION).addKeyDependency(CollectionModule.STRATEGY); + public static final FunctionDependency LINKED_CUSTOM_SET = MODULE.createDependency("LinkedCustomHashSet").addKeyDependency(ORDERED_SET).addKeyDependency(CUSTOM_SET); + public static final FunctionDependency AVL_TREE_SET = MODULE.createDependency("AVLTreeSet").addKeyDependency(SORTED_SET).addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency RB_TREE_SET = MODULE.createDependency("RBTreeSet").addKeyDependency(SORTED_SET).addKeyDependency(IMPLEMENTATION); @Override public String getModuleName() { return "Set"; } diff --git a/src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template b/src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template index 73ea018..7937a6e 100644 --- a/src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template +++ b/src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template @@ -1,19 +1,11 @@ package speiger.src.collections.PACKAGE.collections; -#if !TYPE_OBJECT -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; -/** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing - */ -public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE, ObjectBidirectionalIterator -#else /** * This is a basically a {@link java.util.ListIterator} without the index functions. * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. * @Type(T) */ public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE -#endif { /** * Returns true if the Iterator has a Previous element @@ -29,11 +21,11 @@ public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE public KEY_TYPE PREVIOUS(); #if !TYPE_OBJECT - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default CLASS_TYPE previous() { return KEY_TO_OBJ(PREVIOUS()); diff --git a/src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template b/src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template index 54a1143..029a8c7 100644 --- a/src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template +++ b/src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template @@ -11,11 +11,15 @@ 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; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +#endif #if INT_LIST_MODULE && !TYPE_INT import speiger.src.collections.ints.lists.IntList; #endif +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif import speiger.src.collections.utils.SanityChecks; /** @@ -532,9 +536,10 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION public int size() { return size; } - +#if SPLIT_ITERATOR_FEATURE @Override public SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 16464); } +#endif @Override public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index) { diff --git a/src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template b/src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template index b8d336b..722e8ee 100644 --- a/src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template +++ b/src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template @@ -13,11 +13,13 @@ import java.util.Collection; import java.util.Iterator; import java.util.Objects; import java.util.NoSuchElementException; +#if SPLIT_ITERATOR_FEATURE import java.util.Spliterator; #if PRIMITIVES import java.util.Spliterator.JAVA_SPLIT_ITERATOR; #endif import java.util.function.Consumer; +#endif import java.util.function.Predicate; #if TYPE_OBJECT import java.util.function.IntFunction; @@ -60,12 +62,14 @@ import speiger.src.collections.objects.utils.ObjectArrays; #if TYPE_OBJECT import speiger.src.collections.utils.Stack; #endif +#if SPLIT_ITERATOR_FEATURE #if PRIMITIVES import java.util.stream.JAVA_STREAM; import java.util.stream.StreamSupport; #endif import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif import speiger.src.collections.utils.SanityChecks; /** @@ -415,7 +419,8 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + +#if SPLIT_ITERATOR_FEATURE #if PRIMITIVES /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. @@ -436,6 +441,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE @Override public SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return new TypeSplitIteratorBRACES(this, first, 0); } +#endif @Override public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) { Objects.requireNonNull(action); @@ -1253,6 +1259,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE } } +#if SPLIT_ITERATOR_FEATURE private static class TypeSplitIterator KEY_GENERIC_TYPE implements SPLIT_ITERATOR KEY_GENERIC_TYPE { static final int BATCH_UNIT = 1 << 10; @@ -1397,4 +1404,5 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE } } #endif +#endif } \ No newline at end of file diff --git a/src/builder/resources/speiger/assets/collections/templates/lists/List.template b/src/builder/resources/speiger/assets/collections/templates/lists/List.template index 3443086..46c5416 100644 --- a/src/builder/resources/speiger/assets/collections/templates/lists/List.template +++ b/src/builder/resources/speiger/assets/collections/templates/lists/List.template @@ -15,7 +15,9 @@ import java.util.function.UnaryOperator; #endif import speiger.src.collections.PACKAGE.collections.COLLECTION; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +#endif import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER; #if !TYPE_OBJECT import speiger.src.collections.PACKAGE.functions.COMPARATOR; @@ -27,7 +29,9 @@ import speiger.src.collections.PACKAGE.utils.LISTS; #if INT_LIST_MODULE && !TYPE_INT import speiger.src.collections.ints.lists.IntList; #endif +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif #if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT import speiger.src.collections.utils.SanityChecks; #endif @@ -594,10 +598,12 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List } #endif #endif +#if SPLIT_ITERATOR_FEATURE /** * 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); } +#endif } \ No newline at end of file diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template index eaa07b7..c215610 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template @@ -3,11 +3,13 @@ package speiger.src.collections.PACKAGE.sets; import java.util.NavigableSet; import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif #if SETS_FEATURE import speiger.src.collections.PACKAGE.utils.SETS; #endif -import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; /** * A Type Specific Navigable Set interface with a couple helper methods @@ -145,6 +147,7 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet public default NAVIGABLE_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); } #endif +#if SPLIT_ITERATOR_FEATURE /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator @@ -152,6 +155,7 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet @Override default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); } +#endif #if !TYPE_OBJECT @Override @Deprecated diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template index f98bf74..c80fa92 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template @@ -1,11 +1,13 @@ package speiger.src.collections.PACKAGE.sets; import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif #if SETS_FEATURE import speiger.src.collections.PACKAGE.utils.SETS; #endif -import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; /** * A Special Set Interface giving Access to some really usefull functions @@ -61,6 +63,7 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE */ public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement); +#if SPLIT_ITERATOR_FEATURE /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator @@ -68,6 +71,7 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE @Override default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); } +#endif /** * A method to get the first element in the set * @return first element in the set diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/Set.template b/src/builder/resources/speiger/assets/collections/templates/sets/Set.template index a83e5c6..aa637d8 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/Set.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/Set.template @@ -4,11 +4,13 @@ import java.util.Set; import speiger.src.collections.PACKAGE.collections.COLLECTION; import speiger.src.collections.PACKAGE.collections.ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif #if SETS_FEATURE import speiger.src.collections.PACKAGE.utils.SETS; #endif -import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; /** @@ -88,10 +90,12 @@ public interface SET KEY_GENERIC_TYPE extends Set, COLLECTION KEY_GE public default SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); } #endif +#if SPLIT_ITERATOR_FEATURE /** * 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); } -} \ No newline at end of file +#endif +} diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template index 01cc4f9..cc00ca5 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template @@ -3,7 +3,9 @@ package speiger.src.collections.PACKAGE.sets; import java.util.SortedSet; import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +#endif #if TYPE_OBJECT import java.util.Comparator; #else @@ -12,7 +14,9 @@ import speiger.src.collections.PACKAGE.functions.COMPARATOR; #if SETS_FEATURE import speiger.src.collections.PACKAGE.utils.SETS; #endif +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif /** * A Type Specific SortedSet implementation to reduce boxing/unboxing @@ -67,6 +71,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte public default SORTED_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); } #endif +#if SPLIT_ITERATOR_FEATURE /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator @@ -74,6 +79,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte @Override default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); } +#endif #if !TYPE_OBJECT /** * A Type Specific SubSet method to reduce boxing/unboxing diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template b/src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template index 0623006..302fae7 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template @@ -25,7 +25,7 @@ import speiger.src.collections.booleans.collections.BooleanIterator; #argument PACKAGE bytes shorts ints longs floats doubles #argument MAPPER ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction #argument FILTER_TYPE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE -#if BOOLEAN_COLLECTION_MODULE +#if FILTER_TYPE import speiger.src.collections.objects.functions.function.MAPPER; import speiger.src.collections.PACKAGE.collections.ITERATOR; #endif