forked from Speiger/Primitive-Collections
435 lines
15 KiB
Plaintext
435 lines
15 KiB
Plaintext
package speiger.src.collections.PACKAGE.lists;
|
|
|
|
import java.util.List;
|
|
#if !TYPE_OBJECT && !TYPE_BOOLEAN
|
|
import java.util.Objects;
|
|
import java.util.function.JAVA_UNARY_OPERATOR;
|
|
import java.util.function.UnaryOperator;
|
|
#else if TYPE_OBJECT
|
|
import java.util.Objects;
|
|
import java.util.function.UnaryOperator;
|
|
#endif
|
|
import java.util.Comparator;
|
|
|
|
import speiger.src.collections.PACKAGE.collections.COLLECTION;
|
|
#if !TYPE_OBJECT
|
|
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
|
|
#endif
|
|
import speiger.src.collections.PACKAGE.utils.ARRAYS;
|
|
#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
|
|
import speiger.src.collections.utils.SanityChecks;
|
|
#endif
|
|
|
|
public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List<CLASS_TYPE>
|
|
{
|
|
#if !TYPE_OBJECT
|
|
/**
|
|
* A Type-Specific add Function to reduce (un)boxing
|
|
* @param e the element to add
|
|
* @return true if the list was modified
|
|
* @see List#add(Object)
|
|
*/
|
|
@Override
|
|
public boolean add(KEY_TYPE e);
|
|
|
|
/**
|
|
* A Type-Specific add Function to reduce (un)boxing
|
|
* @param e the element to add
|
|
* @param index index at which the specified element is to be inserted
|
|
* @see List#add(int, Object)
|
|
*/
|
|
public void add(int index, KEY_TYPE e);
|
|
|
|
#endif
|
|
/**
|
|
* A Type-Specific addAll Function to reduce (un)boxing
|
|
* @param c the elements that need to be added
|
|
* @param index index at which the specified elements is to be inserted
|
|
* @return true if the list was modified
|
|
* @see java.util.List#addAll(int, Collection)
|
|
*/
|
|
public boolean addAll(int index, COLLECTION KEY_GENERIC_TYPE c);
|
|
|
|
/**
|
|
* A Type-Specific and optimized addAll function that allows a faster transfer of elements
|
|
* @param c the elements that need to be added
|
|
* @return true if the list was modified
|
|
*/
|
|
public boolean addAll(LIST KEY_GENERIC_TYPE c);
|
|
|
|
/**
|
|
* A Type-Specific and optimized addAll function that allows a faster transfer of elements
|
|
* @param c the elements that need to be added
|
|
* @param index index at which the specified elements is to be inserted
|
|
* @return true if the list was modified
|
|
*/
|
|
public boolean addAll(int index, LIST KEY_GENERIC_TYPE c);
|
|
|
|
#if !TYPE_OBJECT
|
|
/**
|
|
* A Type-Specific get function to reduce (un)boxing
|
|
* @param index the index of the value that is requested
|
|
* @return the value at the given index
|
|
* @throws IndexOutOfBoundsException if the index is not within the list range
|
|
* @see List#get(int)
|
|
*/
|
|
public KEY_TYPE GET_KEY(int index);
|
|
|
|
/**
|
|
* A Type-Specific set function to reduce (un)boxing
|
|
* @param index index of the element to replace
|
|
* @param e element to be stored at the specified position
|
|
* @return the element previously at the specified position
|
|
* @throws IndexOutOfBoundsException if the index is not within the list range
|
|
* @see List#set(int, Object)
|
|
*/
|
|
public KEY_TYPE set(int index, KEY_TYPE e);
|
|
|
|
/**
|
|
* A Type-Specific remove function to reduce (un)boxing
|
|
* @param index the index of the element to be removed
|
|
* @return the element previously at the specified position
|
|
* @see List#remove(int)
|
|
*/
|
|
public KEY_TYPE REMOVE(int index);
|
|
|
|
/**
|
|
* A Type-Specific indexOf function to reduce (un)boxing
|
|
* @param e the element that is searched for
|
|
* @return the index of the element if found. (if not found then -1)
|
|
* @note does not support null values
|
|
*/
|
|
public int indexOf(KEY_TYPE e);
|
|
|
|
/**
|
|
* A Type-Specific lastIndexOf function to reduce (un)boxing
|
|
* @param e the element that is searched for
|
|
* @return the lastIndex of the element if found. (if not found then -1)
|
|
* @note does not support null values
|
|
*/
|
|
public int lastIndexOf(KEY_TYPE e);
|
|
|
|
#if !TYPE_BOOLEAN
|
|
/**
|
|
* A Type-Specific replace function to reduce (un)boxing
|
|
* @param o the action to replace the values
|
|
* @throws NullPointerException if o is null
|
|
*/
|
|
public default void REPLACE(JAVA_UNARY_OPERATOR o) {
|
|
Objects.requireNonNull(o);
|
|
LIST_ITERATOR iter = listIterator();
|
|
while (iter.hasNext())
|
|
#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
|
|
iter.set(SanityChecks.SANITY_CAST(o.APPLY_CAST(iter.NEXT())));
|
|
#else
|
|
iter.set(o.APPLY(iter.NEXT()));
|
|
#endif
|
|
}
|
|
|
|
#endif
|
|
#else
|
|
/**
|
|
* A function to replace all values in the list
|
|
* @param o the action to replace the values
|
|
* @throws NullPointerException if o is null
|
|
*/
|
|
@Override
|
|
public default void replaceAll(UnaryOperator<CLASS_TYPE> o) {
|
|
Objects.requireNonNull(o);
|
|
LIST_ITERATOR KEY_GENERIC_TYPE iter = listIterator();
|
|
while (iter.hasNext()) iter.set(o.apply(iter.NEXT()));
|
|
}
|
|
|
|
#endif
|
|
/**
|
|
* A function to fast add elements to the list
|
|
* @param a the elements that should be added
|
|
* @throws IndexOutOfBoundsException if from is outside of the lists range
|
|
*/
|
|
public default void addElements(KEY_TYPE... a) { addElements(0, a, 0, a.length); }
|
|
|
|
/**
|
|
* A function to fast add elements to the list
|
|
* @param from the index where the elements should be added into the list
|
|
* @param a the elements that should be added
|
|
* @throws IndexOutOfBoundsException if from is outside of the lists range
|
|
*/
|
|
public default void addElements(int from, KEY_TYPE... a) { addElements(from, a, 0, a.length); }
|
|
|
|
/**
|
|
* A function to fast add elements to the list
|
|
* @param from the index where the elements should be added into the list
|
|
* @param a the elements that should be added
|
|
* @param offset the start index of the array should be read from
|
|
* @param length how many elements should be read from
|
|
* @throws IndexOutOfBoundsException if from is outside of the lists range
|
|
* @throws IllegalStateException if offset or length are smaller then 0 or exceed the array length
|
|
*/
|
|
public void addElements(int from, KEY_TYPE[] a, int offset, int length);
|
|
|
|
/**
|
|
* A function to fast fetch elements from the list
|
|
* @param from index where the list should be fetching elements from
|
|
* @param a the array where the values should be inserted to
|
|
* @return the inputArray
|
|
* @throws NullPointerException if the array is null
|
|
* @throws IndexOutOfBoundsException if from is outside of the lists range
|
|
* @throws IllegalStateException if offset or length are smaller then 0 or exceed the array length
|
|
*/
|
|
public default KEY_TYPE[] getElements(int from, KEY_TYPE[] a) { return getElements(from, a, 0, a.length); }
|
|
|
|
/**
|
|
* A function to fast fetch elements from the list
|
|
* @param from index where the list should be fetching elements from
|
|
* @param a the array where the values should be inserted to
|
|
* @param offset the startIndex of where the array should be written to
|
|
* @param length the number of elements the values should be fetched from
|
|
* @return the inputArray
|
|
* @throws NullPointerException if the array is null
|
|
* @throws IndexOutOfBoundsException if from is outside of the lists range
|
|
* @throws IllegalStateException if offset or length are smaller then 0 or exceed the array length
|
|
*/
|
|
public KEY_TYPE[] getElements(int from, KEY_TYPE[] a, int offset, int length);
|
|
|
|
/**
|
|
* a function to fast remove elements from the list.
|
|
* @param from the start index of where the elements should be removed from (inclusive)
|
|
* @param to the end index of where the elements should be removed to (exclusive)
|
|
*/
|
|
public void removeElements(int from, int to);
|
|
|
|
#if TYPE_OBJECT
|
|
/**
|
|
* A function to fast extract elements out of the list, this removes the elements that were fetched.
|
|
* @param from the start index of where the elements should be fetched from (inclusive)
|
|
* @param to the end index of where the elements should be fetched to (exclusive)
|
|
* @param type the type of the OutputArray
|
|
* @return a array of the elements that were fetched
|
|
*/
|
|
public <K> K[] extractElements(int from, int to, Class<K> type);
|
|
|
|
/**
|
|
* Sorts the elements specified by the Natural order either by using the Comparator or the elements
|
|
* @see List#sort(Comparator)
|
|
* @see ARRAYS#stableSort(KEY_TYPE[], Comparator)
|
|
*/
|
|
@Override
|
|
public default void sort(Comparator<? super CLASS_TYPE> c) {
|
|
KEY_TYPE[] array = (KEY_TYPE[])TO_ARRAY();
|
|
if(c != null) ARRAYS.stableSort(array, c);
|
|
else ARRAYS.stableSort((Comparable[])array);
|
|
LIST_ITERATOR KEY_GENERIC_TYPE iter = listIterator();
|
|
for (int i = 0,m=size();i<m && iter.hasNext();i++) {
|
|
iter.NEXT();
|
|
iter.set(array[i]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sorts the elements specified by the Natural order either by using the Comparator or the elements using a unstable sort
|
|
* @see List#sort(Comparator)
|
|
* @see ARRAYS#unstableSort(KEY_TYPE[], Comparator)
|
|
*/
|
|
public default void unstableSort(Comparator<? super CLASS_TYPE> c) {
|
|
KEY_TYPE[] array = (KEY_TYPE[])TO_ARRAY();
|
|
if(c != null) ARRAYS.unstableSort(array, c);
|
|
else ARRAYS.unstableSort((Comparable[])array);
|
|
LIST_ITERATOR KEY_GENERIC_TYPE iter = listIterator();
|
|
for (int i = 0,m=size();i<m && iter.hasNext();i++) {
|
|
iter.NEXT();
|
|
iter.set(array[i]);
|
|
}
|
|
}
|
|
|
|
#else
|
|
/**
|
|
* A function to fast extract elements out of the list, this removes the elements that were fetched.
|
|
* @param from the start index of where the elements should be fetched from (inclusive)
|
|
* @param to the end index of where the elements should be fetched to (exclusive)
|
|
* @return a array of the elements that were fetched
|
|
*/
|
|
public KEY_TYPE[] extractElements(int from, int to);
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
default void sort(Comparator<? super CLASS_TYPE> c) {
|
|
sort((K, V) -> c.compare(KEY_TO_OBJ(K), KEY_TO_OBJ(V)));
|
|
}
|
|
|
|
/**
|
|
* Sorts the elements specified by the Natural order either by using the Comparator or the elements
|
|
* @param c the sorter of the elements, can be null
|
|
* @see List#sort(Comparator)
|
|
* @see ARRAYS#stableSort(KEY_TYPE[], COMPARATOR)
|
|
*/
|
|
public default void sort(COMPARATOR c) {
|
|
KEY_TYPE[] array = TO_ARRAY();
|
|
if(c != null) ARRAYS.stableSort(array, c);
|
|
else ARRAYS.stableSort(array);
|
|
LIST_ITERATOR KEY_GENERIC_TYPE iter = listIterator();
|
|
for (int i = 0,m=size();i<m && iter.hasNext();i++) {
|
|
iter.NEXT();
|
|
iter.set(array[i]);
|
|
}
|
|
}
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Deprecated
|
|
public default void unstableSort(Comparator<? super CLASS_TYPE> c) {
|
|
unstableSort((K, V) -> c.compare(KEY_TO_OBJ(K), KEY_TO_OBJ(V)));
|
|
}
|
|
|
|
/**
|
|
* Sorts the elements specified by the Natural order either by using the Comparator or the elements using a unstable sort
|
|
* @param c the sorter of the elements, can be null
|
|
* @see List#sort(Comparator)
|
|
* @see ARRAYS#unstableSort(KEY_TYPE[], COMPARATOR)
|
|
*/
|
|
public default void unstableSort(COMPARATOR c) {
|
|
KEY_TYPE[] array = TO_ARRAY();
|
|
if(c != null) ARRAYS.unstableSort(array, c);
|
|
else ARRAYS.unstableSort(array);
|
|
LIST_ITERATOR KEY_GENERIC_TYPE iter = listIterator();
|
|
for (int i = 0,m=size();i<m && iter.hasNext();i++) {
|
|
iter.NEXT();
|
|
iter.set(array[i]);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
/**
|
|
* A Type-Specific Iterator of listIterator
|
|
* @see List#listIterator
|
|
*/
|
|
@Override
|
|
public LIST_ITERATOR KEY_GENERIC_TYPE listIterator();
|
|
|
|
/**
|
|
* A Type-Specific Iterator of listIterator
|
|
* @see List#listIterator(int)
|
|
*/
|
|
@Override
|
|
public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index);
|
|
|
|
/**
|
|
* A Type-Specific List of subList
|
|
* @see List#subList(int, int)
|
|
*/
|
|
@Override
|
|
public LIST KEY_GENERIC_TYPE subList(int from, int to);
|
|
|
|
/**
|
|
* A function to ensure the elements are within the requested size.
|
|
* If smaller then the stored elements they get removed as needed.
|
|
* If bigger it is ensured that enough room is provided depending on the implementation
|
|
* @param size the requested amount of elements/room for elements
|
|
*/
|
|
public void size(int size);
|
|
|
|
#if !TYPE_OBJECT
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default boolean add(CLASS_TYPE e) {
|
|
return COLLECTION.super.add(e);
|
|
}
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default CLASS_TYPE get(int index) {
|
|
return KEY_TO_OBJ(GET_KEY(index));
|
|
}
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default CLASS_TYPE set(int index, CLASS_TYPE e) {
|
|
return KEY_TO_OBJ(set(index, OBJ_TO_KEY(e)));
|
|
}
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default int indexOf(Object o) {
|
|
return indexOf(CLASS_TO_KEY(o));
|
|
}
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default int lastIndexOf(Object o) {
|
|
return lastIndexOf(CLASS_TO_KEY(o));
|
|
}
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default boolean contains(Object o) {
|
|
return COLLECTION.super.contains(o);
|
|
}
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default boolean remove(Object o) {
|
|
return COLLECTION.super.remove(o);
|
|
}
|
|
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default CLASS_TYPE remove(int index) {
|
|
return KEY_TO_OBJ(REMOVE(index));
|
|
}
|
|
|
|
#if !TYPE_BOOLEAN
|
|
/** {@inheritDoc}
|
|
* <p>This default implementation delegates to the corresponding type-specific function.
|
|
* @deprecated Please use the corresponding type-specific function instead.
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public default void replaceAll(UnaryOperator<CLASS_TYPE> o) {
|
|
Objects.requireNonNull(o);
|
|
#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
|
|
REPLACE(T -> OBJ_TO_KEY(o.apply(KEY_TO_OBJ((KEY_TYPE)T))));
|
|
#else
|
|
REPLACE(T -> OBJ_TO_KEY(o.apply(KEY_TO_OBJ(T))));
|
|
#endif
|
|
}
|
|
#endif
|
|
#endif
|
|
} |