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