one.microstream.collections

Class AbstractArrayStorage

java.lang.Object

one.microstream.collections.AbstractArrayStorage

public abstract class AbstractArrayStorage
extends Object

Abstract class with static delegate array logic methods to be used as pseudo-array-inherent methods.

The passed array and size are handled as pseudo implementation details and thus are never sanity-checked.

See ChainStorage and for example ChainStorageStrong as a comparable actual logic implementation without delegate-pseudo-character.

Constructor Summary

Constructors

Constructor and Description
AbstractArrayStorage()

Method Summary

Modifier and Type	Method and Description
static <E> int	addAll(E[] data, int size, E[] src, int srcIndex, int srcLength, Predicate<? super E> predicate)
static <E> VarString	appendTo(E[] data, int size, VarString vc)
static <E> VarString	appendTo(E[] data, int size, VarString vc, BiConsumer<VarString,? super E> appender)
static <E> VarString	appendTo(E[] data, int size, VarString vc, BiConsumer<VarString,? super E> appender, char separator)
static <E> VarString	appendTo(E[] data, int size, VarString vc, BiConsumer<VarString,? super E> appender, String separator)
static <E> VarString	appendTo(E[] data, int size, VarString vc, char separator)
static <E> VarString	appendTo(E[] data, int size, VarString vc, String separator)
static <E> int	binarySearch(E[] data, int size, E element, Comparator<? super E> comparator)
static int	checkIterationDirection(int size, int offset, int length) Deprecated.
static <E> boolean	containsAll(E[] data, int size, XGettingCollection<? extends E> elements)
static <E> boolean	containsAll(E[] data, int size, XGettingCollection<? extends E> elements, Equalator<? super E> equalator)
static <E,C extends Consumer<? super E>> C	copySelection(E[] data, int size, long[] indices, C target)
static <E,C extends Consumer<? super E>> C	distinct(E[] data, int size, C target)
static <E,C extends Consumer<? super E>> C	distinct(E[] data, int size, C target, Equalator<? super E> equalator)
static <E> boolean	equalsContent(E[] data, int size, Collection<? extends E> collection, Equalator<? super E> equalator)
static <E> boolean	equalsContent(E[] data, int size, XGettingCollection<? extends E> samples, Equalator<? super E> equalator)
static <E,C extends Consumer<? super E>> C	except(E[] data, int size, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)
static <E> void	fill(E[] data, int size, int offset, int length, E element)
static <E,R> R	forwardAggregate(E[] data, int lowOffset, int highBound, Aggregator<? super E,R> aggregator)
static <E> boolean	forwardApplies(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)
static <E,R> R	forwardConditionalAggregate(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate, Aggregator<? super E,R> aggregator)
static <E> int	forwardConditionalCount(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)
static <E> int	forwardConditionalIndexOf(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)
static <E> void	forwardConditionalIterate(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate, Consumer<? super E> procedure)
static <E> boolean	forwardContains(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)
static <E> boolean	forwardContainsSame(E[] data, int lowOffset, int highBound, E element)
static <E,C extends Consumer<? super E>> C	forwardCopyTo(E[] data, int lowOffset, int highBound, C target)
static <E,C extends Consumer<? super E>> C	forwardCopyTo(E[] data, int lowOffset, int highBound, C target, Predicate<? super E> predicate)
static <E> int	forwardCount(E[] data, int lowOffset, int highBound, E element)
static <E> int	forwardIndexOf(E[] data, int lowOffset, int highBound, E element)
static <E> void	forwardIterate(E[] data, int lowOffset, int highBound, Consumer<? super E> procedure)
static <E,A> void	forwardJoin(E[] data, int lowOffset, int highBound, BiConsumer<? super E,? super A> joiner, A aggregate)
static <E> boolean	forwardNullContained(E[] data, int lowOffset, int highBound)
static <E> E	forwardQueryElement(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate, E notFoundMarker)
static <E> int	forwardScan(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)
static <E> E	forwardSearchElement(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate, E notFoundMarker)
static <E> boolean	hasDistinctValues(E[] data, int size)
static <E> boolean	hasDistinctValues(E[] data, int size, Equalator<? super E> equalator)
static <E> boolean	hasDistinctValues(E[] data, int size, HashEqualator<? super E> equalator)
static <E,C extends Consumer<? super E>> C	intersect(E[] data, int size, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)
static <E> boolean	isSorted(E[] data, int size, Comparator<? super E> comparator)
static <E> void	iterate(E[] data, int size, Consumer<? super E> iterator)
static <E> void	iterate(E[] data, int size, IndexedAcceptor<? super E> procedure)
static <E,A> void	join(E[] data, int size, BiConsumer<? super E,? super A> joiner, A aggregate) Iterates over all elements of data which index is lower than the given size.
static <E> int	lastIndexOf(E[] data, int size, Predicate<? super E> predicate)
static <E> E	max(E[] data, int size, Comparator<? super E> comparator)
static <E> int	maxIndex(E[] data, int size, Comparator<? super E> comparator)
static <E> E	min(E[] data, int size, Comparator<? super E> comparator)
static <E> int	minIndex(E[] data, int size, Comparator<? super E> comparator)
static <E> int	moveSelection(E[] data, int size, long[] indices, Consumer<? super E> target, E removeMarker)
static <E> int	moveTo(E[] data, int size, Consumer<? super E> target, Predicate<? super E> predicate, E removeMarker)
static <E> int	process(E[] data, int size, Consumer<? super E> procedure, E removeMarker)
static <E,R> R	rangedAggregate(E[] data, int size, int offset, int length, Aggregator<? super E,R> aggregator)
static <E> VarString	rangedAppendTo(E[] data, int size, int offset, int length, VarString vc)
static <E> VarString	rangedAppendTo(E[] data, int size, int offset, int length, VarString vc, BiConsumer<VarString,? super E> appender)
static <E> VarString	rangedAppendTo(E[] data, int size, int offset, int length, VarString vc, BiConsumer<VarString,? super E> appender, char separator)
static <E> VarString	rangedAppendTo(E[] data, int size, int offset, int length, VarString vc, BiConsumer<VarString,? super E> appender, String separator)
static <E> VarString	rangedAppendTo(E[] data, int size, int offset, int length, VarString vc, char separator)
static <E> VarString	rangedAppendTo(E[] data, int size, int offset, int length, VarString vc, String separator)
static <E> boolean	rangedApplies(E[] data, int size, int offset, int length, Predicate<? super E> predicate)
static <E> int	rangedBinarySearch(E[] data, int size, int offset, int length, E element, Comparator<? super E> comparator)
static <E,R> R	rangedConditionalAggregate(E[] data, int size, int offset, int length, Predicate<? super E> predicate, Aggregator<? super E,R> aggregator)
static <E> int	rangedConditionalCount(E[] data, int size, int offset, int length, Predicate<? super E> predicate)
static <E> int	rangedConditionalIndexOf(E[] data, int size, int offset, int length, Predicate<? super E> predicate)
static <E> void	rangedConditionalIterate(E[] data, int size, int offset, int length, Predicate<? super E> predicate, Consumer<? super E> procedure)
static <E> boolean	rangedContains(E[] data, int size, int offset, int length, Predicate<? super E> predicate)
static <E> boolean	rangedContainsAll(E[] data, int size, int offset, int length, XGettingCollection<? extends E> elements)
static <E> boolean	rangedContainsNull(E[] data, int size, int offset, int length)
static <E> boolean	rangedContainsSame(E[] data, int size, int offset, int length, E element)
static <E,C extends Consumer<? super E>> C	rangedCopyTo(E[] data, int size, int offset, int length, C target)
static <E,C extends Consumer<? super E>> C	rangedCopyTo(E[] data, int size, int offset, int length, C target, Predicate<? super E> predicate)
static <E,T> T[]	rangedCopyTo(E[] data, int size, int offset, int length, T[] target, int targetOffset)
static <E> int	rangedCount(E[] data, int size, int offset, int length, E element)
static <E,C extends Consumer<? super E>> C	rangedDistinct(E[] data, int size, int offset, int length, C target)
static <E,C extends Consumer<? super E>> C	rangedDistinct(E[] data, int size, int offset, int length, C target, Equalator<? super E> equalator)
static <E> boolean	rangedEqualsContent(E[] data, int size, int offset, int length, List<? extends E> list, Equalator<? super E> equalator)
static <E> boolean	rangedEqualsContent(E[] data, int size, int offset, int length, XGettingSequence<? extends E> sequence, Equalator<? super E> equalator)
static <E,C extends Consumer<? super E>> C	rangedExcept(E[] data, int size, int offset, int length, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)
static <E> boolean	rangedHasUniqueValues(E[] data, int size, int offset, int length)
static <E> boolean	rangedHasUniqueValues(E[] data, int size, int offset, int length, Equalator<? super E> equalator)
static <E> int	rangedIndexOF(E[] data, int size, int offset, int length, E element)
static <E,C extends Consumer<? super E>> C	rangedIntersect(E[] data, int size, int offset, int length, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)
static <E> boolean	rangedIsSorted(E[] data, int size, int offset, int length, Comparator<? super E> comparator)
static <E> void	rangedIterate(E[] data, int size, int offset, int length, Consumer<? super E> procedure)
static <E> void	rangedIterate(E[] data, int size, int offset, int length, IndexedAcceptor<? super E> procedure)
static <E,A> void	rangedJoin(E[] data, int size, int offset, int length, BiConsumer<? super E,? super A> joiner, A aggregate)
static <E> int	rangedModify(E[] data, int size, int offset, int length, Function<E,E> mapper)
static <E> int	rangedMoveTo(E[] data, int size, int offset, int length, Consumer<? super E> target, Predicate<? super E> predicate, E removeMarker)
static <E> int	rangedProcess(E[] data, int size, int offset, int length, Consumer<? super E> procedure, E removeMarker)
static <E> E	rangedQueryElement(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E notFoundMarker)
static <E> int	rangedReduce(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E removeMarker)
static <E> int	rangedRemove(E[] data, int size, int offset, int length, E element)
static <E> int	rangedRemove(E[] data, int size, int offset, int length, E sample, Equalator<? super E> equalator)
static <E> int	rangedRemoveAll(E[] data, int size, int offset, int length, XGettingCollection<? extends E> elements)
static <E> int	rangedRemoveAll(E[] data, int size, int offset, int length, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, E removeMarker)
static <E> int	rangedRemoveDuplicates(E[] data, int size, int offset, int length, E removeMarker)
static <E> int	rangedRemoveDuplicates(E[] data, int size, int offset, int length, Equalator<? super E> equalator, E removeMarker)
static <E> int	rangedRemoveNull(E[] data, int size, int offset, int length)
static <E> boolean	rangedRemoveOne(E[] data, int size, int offset, int length, E element)
static <E> boolean	rangedRemoveOne(E[] data, int size, int offset, int length, E sample, Equalator<? super E> equalator)
static <E> int	rangedReplace(E[] data, int size, int offset, int length, E oldElement, E newElement)
static <E> long	rangedReplace(E[] data, int size, int offset, int length, E sample, E newElement, Equalator<? super E> equalator)
static <E> int	rangedReplace(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E newElement)
static <E> int	rangedReplaceAll(E[] data, int size, int offset, int length, XGettingCollection<E> oldElements, E newElement)
static <E> int	rangedReplaceAll(E[] data, int size, int offset, int length, XGettingCollection<E> samples, E newElement, Equalator<? super E> equalator)
static <E> int	rangedReplaceAll(E[] data, int size, int offset, int length, XMap<E,E> replacementMapping)
static <E> int	rangedReplaceOne(E[] data, int size, int offset, int length, E oldElement, E newElement)
static <E> int	rangedReplaceOne(E[] data, int size, int offset, int length, E sample, E newElement, Equalator<? super E> equalator)
static <E> int	rangedReplaceOne(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E newElement)
static <E> int	rangedRetainAll(E[] data, int size, int offset, int length, XGettingCollection<E> elements, E removeMarker)
static <E> int	rangedRetainAll(E[] data, int size, int offset, int length, XGettingCollection<E> samples, Equalator<? super E> equalator, E removeMarker)
static <E> E	rangedRetrieve(E[] data, int size, int offset, int length, E element, E notFoundMarker)
static <E> E	rangedRetrieve(E[] data, int size, int offset, int length, E sample, Equalator<? super E> equalator, E notFoundMarker)
static <E> E	rangedRetrieve(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E notFoundMarker)
static <E> void	rangedReverse(E[] data, int size, int offset, int length)
static <E> int	rangedScan(E[] data, int size, int offset, int length, Predicate<? super E> predicate)
static <E> E	rangedSearchElement(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E notFoundMarker)
static <E> void	rangedShuffle(E[] data, int size, int offset, int length)
static <E> void	rangedSort(E[] data, int size, int offset, int length, Comparator<? super E> comparator)
static <E> void	rangedSortInsertion(E[] data, int size, int offset, int length, Comparator<? super E> comparator)
static <E> void	rangedSortMerge(E[] data, int size, int offset, int length, Comparator<? super E> comparator)
static <E> void	rangedSortQuick(E[] data, int size, int offset, int length, Comparator<? super E> comparator)
static <E> E[]	rangedToArray(E[] data, int size, int offset, int length, Class<E> type)
static Object[]	rangedToArray(Object[] data, int size, int offset, int length)
static <T> T[]	rangedToArray(Object[] data, int size, int offset, int length, T[] a)
static <E,C extends Consumer<? super E>> C	rangedUnion(E[] data, int size, int offset, int length, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)
static <E> int	reduce(E[] data, int size, Predicate<? super E> predicate, E removeMarker)
static <E> int	removeDuplicates(E[] data, int size, E removeMarker)
static <E> int	removeDuplicates(E[] data, int size, Equalator<? super E> equalator, E removeMarker)
static <E> boolean	removeOne(E[] data, int size, E element)
static <E> boolean	removeOne(E[] data, int size, E sample, Equalator<? super E> equalator)
static <E> int	removeRange(E[] data, int size, int offset, int length)
static <E> int	removeSelection(E[] data, int size, long[] indices, E removeMarker)
static <E> int	replace(E[] data, int size, E oldElement, E newElement)
static <E> int	replace(E[] data, int size, E sample, E newElement, Equalator<? super E> equalator)
static <E,U extends E> int	replaceAll(E[] data, int size, XGettingCollection<U> oldElements, E newElement, E marker)
static <E,U extends E> int	replaceAll(E[] data, int size, XGettingCollection<U> samples, E newElement, Equalator<? super E> equalator, E marker)
static <E> int	replaceAll(E[] data, int size, XMap<E,E> replacementMapping)
static <E> boolean	replaceOne(E[] data, int size, E oldElement, E newElement)
static <E> boolean	replaceOne(E[] data, int size, E sample, E newElement, Equalator<? super E> equalator)
static <E> int	retainAll(E[] data, int size, XGettingCollection<E> elements, E removeMarker)
static <E> int	retainAll(E[] data, int size, XGettingCollection<E> samples, Equalator<? super E> equalator, E removeMarker)
static <E> int	retainRange(E[] data, int size, int offset, int length)
static <E> E	retrieve(E[] data, int size, E element, E notFoundMarker)
static <E> E	retrieve(E[] data, int size, E sample, Equalator<? super E> equalator, E notFoundMarker)
static <E> E	retrieve(E[] data, int size, Predicate<? super E> predicate, E notFoundMarker)
static <E> void	reverse(E[] data, int size)
static <E,R> R	reverseAggregate(E[] data, int highOffset, int lowEnd, Aggregator<? super E,R> aggregator)
static <E> boolean	reverseApplies(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)
static <E,R> R	reverseConditionalAggregate(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate, Aggregator<? super E,R> aggregator)
static <E> int	reverseConditionalCount(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)
static <E> int	reverseConditionalIndexOf(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)
static <E> void	reverseConditionalIterate(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate, Consumer<? super E> procedure)
static <E> boolean	reverseContains(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)
static <E> boolean	reverseContainsSame(E[] data, int lowOffset, int highBound, E element)
static <E,C extends Consumer<? super E>> C	reverseCopyTo(E[] data, int highOffset, int lowEnd, C target)
static <E,C extends Consumer<? super E>> C	reverseCopyTo(E[] data, int highOffset, int lowEnd, C target, Predicate<? super E> predicate)
static <E> int	reverseCount(E[] data, int highOffset, int lowEnd, E element)
static <E> int	reverseIndexOf(E[] data, int highOffset, int lowEnd, E element)
static <E> void	reverseIterate(E[] data, int highOffset, int lowEnd, Consumer<? super E> procedure)
static <E,A> void	reverseJoin(E[] data, int highOffset, int lowEnd, BiConsumer<? super E,? super A> joiner, A aggregate)
static <E> boolean	reverseNullContained(E[] data, int highOffset, int lowEnd)
static <E> E	reverseQueryElement(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate, E notFoundMarker)
static <E> int	reverseScan(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)
static <E> E	reverseSearchElement(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate, E notFoundMarker)
static <E> void	set(E[] data, int size, int offset, E[] elements)
static <E> void	set(E[] data, int size, int offset, E[] src, int srcIndex, int srcLength)
static <E> void	set(E[] data, int size, int offset, XGettingSequence<? extends E> elements, long elementsOffset, long elementsLength)
static <E> void	shuffle(E[] data, int size)
static <E> void	sortInsertion(E[] data, int size, Comparator<? super E> comparator)
static <E> long	substitute(E[] data, int size, Function<? super E,? extends E> mapper)
static <E> long	substitute(E[] data, int size, Predicate<? super E> predicate, E newElement)
static <E> long	substitute(E[] data, int size, Predicate<? super E> predicate, Function<E,E> mapper)
static <E> boolean	substituteOne(E[] data, int size, Predicate<? super E> predicate, E replacement)
static <E> void	swap(E[] data, int size, int indexA, int indexB)
static <E> void	swap(E[] data, int size, int indexA, int indexB, int length)
static <T> T[]	toReversed(T[] array, int size)
static String	toString(Object[] data, int size)
static <E,C extends Consumer<? super E>> C	union(E[] data, int size, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)
static void	validateRange0toUpperBound(int upperBound, int offset, int length)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AbstractArrayStorage

public AbstractArrayStorage()

Method Detail

validateRange0toUpperBound

public static final void validateRange0toUpperBound(int upperBound,
                                                    int offset,
                                                    int length)

rangedIndexOF

public static final <E> int rangedIndexOF(E[] data,
                                          int size,
                                          int offset,
                                          int length,
                                          E element)

forwardIndexOf

public static final <E> int forwardIndexOf(E[] data,
                                           int lowOffset,
                                           int highBound,
                                           E element)

reverseIndexOf

public static final <E> int reverseIndexOf(E[] data,
                                           int highOffset,
                                           int lowEnd,
                                           E element)

rangedConditionalIndexOf

public static final <E> int rangedConditionalIndexOf(E[] data,
                                                     int size,
                                                     int offset,
                                                     int length,
                                                     Predicate<? super E> predicate)

forwardConditionalIndexOf

public static final <E> int forwardConditionalIndexOf(E[] data,
                                                      int lowOffset,
                                                      int highBound,
                                                      Predicate<? super E> predicate)

reverseConditionalIndexOf

public static final <E> int reverseConditionalIndexOf(E[] data,
                                                      int highOffset,
                                                      int lowEnd,
                                                      Predicate<? super E> predicate)

rangedScan

public static final <E> int rangedScan(E[] data,
                                       int size,
                                       int offset,
                                       int length,
                                       Predicate<? super E> predicate)

forwardScan

public static final <E> int forwardScan(E[] data,
                                        int lowOffset,
                                        int highBound,
                                        Predicate<? super E> predicate)

reverseScan

public static final <E> int reverseScan(E[] data,
                                        int highOffset,
                                        int lowEnd,
                                        Predicate<? super E> predicate)

rangedContains

public static final <E> boolean rangedContains(E[] data,
                                               int size,
                                               int offset,
                                               int length,
                                               Predicate<? super E> predicate)

forwardContains

public static final <E> boolean forwardContains(E[] data,
                                                int lowOffset,
                                                int highBound,
                                                Predicate<? super E> predicate)

reverseContains

public static final <E> boolean reverseContains(E[] data,
                                                int highOffset,
                                                int lowEnd,
                                                Predicate<? super E> predicate)

rangedApplies

public static final <E> boolean rangedApplies(E[] data,
                                              int size,
                                              int offset,
                                              int length,
                                              Predicate<? super E> predicate)

forwardApplies

public static final <E> boolean forwardApplies(E[] data,
                                               int lowOffset,
                                               int highBound,
                                               Predicate<? super E> predicate)

reverseApplies

public static final <E> boolean reverseApplies(E[] data,
                                               int highOffset,
                                               int lowEnd,
                                               Predicate<? super E> predicate)

rangedConditionalCount

public static final <E> int rangedConditionalCount(E[] data,
                                                   int size,
                                                   int offset,
                                                   int length,
                                                   Predicate<? super E> predicate)

forwardConditionalCount

public static final <E> int forwardConditionalCount(E[] data,
                                                    int lowOffset,
                                                    int highBound,
                                                    Predicate<? super E> predicate)

reverseConditionalCount

public static final <E> int reverseConditionalCount(E[] data,
                                                    int highOffset,
                                                    int lowEnd,
                                                    Predicate<? super E> predicate)

rangedSearchElement

public static final <E> E rangedSearchElement(E[] data,
                                              int size,
                                              int offset,
                                              int length,
                                              Predicate<? super E> predicate,
                                              E notFoundMarker)

forwardSearchElement

public static final <E> E forwardSearchElement(E[] data,
                                               int lowOffset,
                                               int highBound,
                                               Predicate<? super E> predicate,
                                               E notFoundMarker)

reverseSearchElement

public static final <E> E reverseSearchElement(E[] data,
                                               int highOffset,
                                               int lowEnd,
                                               Predicate<? super E> predicate,
                                               E notFoundMarker)

rangedQueryElement

public static final <E> E rangedQueryElement(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             Predicate<? super E> predicate,
                                             E notFoundMarker)

forwardQueryElement

public static final <E> E forwardQueryElement(E[] data,
                                              int lowOffset,
                                              int highBound,
                                              Predicate<? super E> predicate,
                                              E notFoundMarker)

reverseQueryElement

public static final <E> E reverseQueryElement(E[] data,
                                              int highOffset,
                                              int lowEnd,
                                              Predicate<? super E> predicate,
                                              E notFoundMarker)

iterate

public static final <E> void iterate(E[] data,
                                     int size,
                                     Consumer<? super E> iterator)

join

public static final <E,A> void join(E[] data,
                                    int size,
                                    BiConsumer<? super E,? super A> joiner,
                                    A aggregate)

Iterates over all elements of data which index is lower than the given size. Calls the joiner with each element and the aggregate.

Type Parameters:

E - type of data

A - type of aggregate

Parameters:

data - which is iterated and given to the joiner

size - of the given data array. The actual size of the data array may be greater, but not smaller.

joiner - is the actual function to do the joining

aggregate - where to join into

rangedIterate

public static final <E> void rangedIterate(E[] data,
                                           int size,
                                           int offset,
                                           int length,
                                           Consumer<? super E> procedure)

rangedJoin

public static final <E,A> void rangedJoin(E[] data,
                                          int size,
                                          int offset,
                                          int length,
                                          BiConsumer<? super E,? super A> joiner,
                                          A aggregate)

forwardIterate

public static final <E> void forwardIterate(E[] data,
                                            int lowOffset,
                                            int highBound,
                                            Consumer<? super E> procedure)

reverseIterate

public static final <E> void reverseIterate(E[] data,
                                            int highOffset,
                                            int lowEnd,
                                            Consumer<? super E> procedure)

forwardJoin

public static final <E,A> void forwardJoin(E[] data,
                                           int lowOffset,
                                           int highBound,
                                           BiConsumer<? super E,? super A> joiner,
                                           A aggregate)

reverseJoin

public static final <E,A> void reverseJoin(E[] data,
                                           int highOffset,
                                           int lowEnd,
                                           BiConsumer<? super E,? super A> joiner,
                                           A aggregate)

rangedConditionalIterate

public static final <E> void rangedConditionalIterate(E[] data,
                                                      int size,
                                                      int offset,
                                                      int length,
                                                      Predicate<? super E> predicate,
                                                      Consumer<? super E> procedure)

forwardConditionalIterate

public static final <E> void forwardConditionalIterate(E[] data,
                                                       int lowOffset,
                                                       int highBound,
                                                       Predicate<? super E> predicate,
                                                       Consumer<? super E> procedure)

reverseConditionalIterate

public static final <E> void reverseConditionalIterate(E[] data,
                                                       int highOffset,
                                                       int lowEnd,
                                                       Predicate<? super E> predicate,
                                                       Consumer<? super E> procedure)

rangedAggregate

public static final <E,R> R rangedAggregate(E[] data,
                                            int size,
                                            int offset,
                                            int length,
                                            Aggregator<? super E,R> aggregator)

forwardAggregate

public static final <E,R> R forwardAggregate(E[] data,
                                             int lowOffset,
                                             int highBound,
                                             Aggregator<? super E,R> aggregator)

reverseAggregate

public static final <E,R> R reverseAggregate(E[] data,
                                             int highOffset,
                                             int lowEnd,
                                             Aggregator<? super E,R> aggregator)

rangedConditionalAggregate

public static final <E,R> R rangedConditionalAggregate(E[] data,
                                                       int size,
                                                       int offset,
                                                       int length,
                                                       Predicate<? super E> predicate,
                                                       Aggregator<? super E,R> aggregator)

forwardConditionalAggregate

public static final <E,R> R forwardConditionalAggregate(E[] data,
                                                        int lowOffset,
                                                        int highBound,
                                                        Predicate<? super E> predicate,
                                                        Aggregator<? super E,R> aggregator)

reverseConditionalAggregate

public static final <E,R> R reverseConditionalAggregate(E[] data,
                                                        int highOffset,
                                                        int lowEnd,
                                                        Predicate<? super E> predicate,
                                                        Aggregator<? super E,R> aggregator)

addAll

public static final <E> int addAll(E[] data,
                                   int size,
                                   E[] src,
                                   int srcIndex,
                                   int srcLength,
                                   Predicate<? super E> predicate)

rangedContainsNull

public static final <E> boolean rangedContainsNull(E[] data,
                                                   int size,
                                                   int offset,
                                                   int length)

forwardNullContained

public static final <E> boolean forwardNullContained(E[] data,
                                                     int lowOffset,
                                                     int highBound)

reverseNullContained

public static final <E> boolean reverseNullContained(E[] data,
                                                     int highOffset,
                                                     int lowEnd)

rangedContainsSame

public static final <E> boolean rangedContainsSame(E[] data,
                                                   int size,
                                                   int offset,
                                                   int length,
                                                   E element)

forwardContainsSame

public static final <E> boolean forwardContainsSame(E[] data,
                                                    int lowOffset,
                                                    int highBound,
                                                    E element)

reverseContainsSame

public static final <E> boolean reverseContainsSame(E[] data,
                                                    int lowOffset,
                                                    int highBound,
                                                    E element)

containsAll

public static final <E> boolean containsAll(E[] data,
                                            int size,
                                            XGettingCollection<? extends E> elements)

rangedContainsAll

public static final <E> boolean rangedContainsAll(E[] data,
                                                  int size,
                                                  int offset,
                                                  int length,
                                                  XGettingCollection<? extends E> elements)

containsAll

public static final <E> boolean containsAll(E[] data,
                                            int size,
                                            XGettingCollection<? extends E> elements,
                                            Equalator<? super E> equalator)

rangedCount

public static final <E> int rangedCount(E[] data,
                                        int size,
                                        int offset,
                                        int length,
                                        E element)

forwardCount

public static final <E> int forwardCount(E[] data,
                                         int lowOffset,
                                         int highBound,
                                         E element)

reverseCount

public static final <E> int reverseCount(E[] data,
                                         int highOffset,
                                         int lowEnd,
                                         E element)

max

public static final <E> E max(E[] data,
                              int size,
                              Comparator<? super E> comparator)

min

public static final <E> E min(E[] data,
                              int size,
                              Comparator<? super E> comparator)

lastIndexOf

public static final <E> int lastIndexOf(E[] data,
                                        int size,
                                        Predicate<? super E> predicate)

maxIndex

public static final <E> int maxIndex(E[] data,
                                     int size,
                                     Comparator<? super E> comparator)

minIndex

public static final <E> int minIndex(E[] data,
                                     int size,
                                     Comparator<? super E> comparator)

rangedCopyTo

public static final <E,C extends Consumer<? super E>> C rangedCopyTo(E[] data,
                                                                     int size,
                                                                     int offset,
                                                                     int length,
                                                                     C target)

forwardCopyTo

public static final <E,C extends Consumer<? super E>> C forwardCopyTo(E[] data,
                                                                      int lowOffset,
                                                                      int highBound,
                                                                      C target)

reverseCopyTo

public static final <E,C extends Consumer<? super E>> C reverseCopyTo(E[] data,
                                                                      int highOffset,
                                                                      int lowEnd,
                                                                      C target)

rangedCopyTo

public static final <E,C extends Consumer<? super E>> C rangedCopyTo(E[] data,
                                                                     int size,
                                                                     int offset,
                                                                     int length,
                                                                     C target,
                                                                     Predicate<? super E> predicate)

forwardCopyTo

public static final <E,C extends Consumer<? super E>> C forwardCopyTo(E[] data,
                                                                      int lowOffset,
                                                                      int highBound,
                                                                      C target,
                                                                      Predicate<? super E> predicate)

reverseCopyTo

public static final <E,C extends Consumer<? super E>> C reverseCopyTo(E[] data,
                                                                      int highOffset,
                                                                      int lowEnd,
                                                                      C target,
                                                                      Predicate<? super E> predicate)

rangedCopyTo

public static final <E,T> T[] rangedCopyTo(E[] data,
                                           int size,
                                           int offset,
                                           int length,
                                           T[] target,
                                           int targetOffset)

copySelection

public static final <E,C extends Consumer<? super E>> C copySelection(E[] data,
                                                                      int size,
                                                                      long[] indices,
                                                                      C target)

binarySearch

public static final <E> int binarySearch(E[] data,
                                         int size,
                                         E element,
                                         Comparator<? super E> comparator)

rangedBinarySearch

public static final <E> int rangedBinarySearch(E[] data,
                                               int size,
                                               int offset,
                                               int length,
                                               E element,
                                               Comparator<? super E> comparator)

intersect

public static final <E,C extends Consumer<? super E>> C intersect(E[] data,
                                                                  int size,
                                                                  XGettingCollection<? extends E> samples,
                                                                  Equalator<? super E> equalator,
                                                                  C target)

except

public static final <E,C extends Consumer<? super E>> C except(E[] data,
                                                               int size,
                                                               XGettingCollection<? extends E> samples,
                                                               Equalator<? super E> equalator,
                                                               C target)

union

public static final <E,C extends Consumer<? super E>> C union(E[] data,
                                                              int size,
                                                              XGettingCollection<? extends E> samples,
                                                              Equalator<? super E> equalator,
                                                              C target)

rangedIntersect

public static final <E,C extends Consumer<? super E>> C rangedIntersect(E[] data,
                                                                        int size,
                                                                        int offset,
                                                                        int length,
                                                                        XGettingCollection<? extends E> samples,
                                                                        Equalator<? super E> equalator,
                                                                        C target)

rangedExcept

public static final <E,C extends Consumer<? super E>> C rangedExcept(E[] data,
                                                                     int size,
                                                                     int offset,
                                                                     int length,
                                                                     XGettingCollection<? extends E> samples,
                                                                     Equalator<? super E> equalator,
                                                                     C target)

rangedUnion

public static final <E,C extends Consumer<? super E>> C rangedUnion(E[] data,
                                                                    int size,
                                                                    int offset,
                                                                    int length,
                                                                    XGettingCollection<? extends E> samples,
                                                                    Equalator<? super E> equalator,
                                                                    C target)

distinct

public static final <E,C extends Consumer<? super E>> C distinct(E[] data,
                                                                 int size,
                                                                 C target)

rangedDistinct

public static final <E,C extends Consumer<? super E>> C rangedDistinct(E[] data,
                                                                       int size,
                                                                       int offset,
                                                                       int length,
                                                                       C target)

distinct

public static final <E,C extends Consumer<? super E>> C distinct(E[] data,
                                                                 int size,
                                                                 C target,
                                                                 Equalator<? super E> equalator)

rangedDistinct

public static final <E,C extends Consumer<? super E>> C rangedDistinct(E[] data,
                                                                       int size,
                                                                       int offset,
                                                                       int length,
                                                                       C target,
                                                                       Equalator<? super E> equalator)

iterate

public static final <E> void iterate(E[] data,
                                     int size,
                                     IndexedAcceptor<? super E> procedure)

rangedIterate

public static final <E> void rangedIterate(E[] data,
                                           int size,
                                           int offset,
                                           int length,
                                           IndexedAcceptor<? super E> procedure)

rangedRemove

public static final <E> int rangedRemove(E[] data,
                                         int size,
                                         int offset,
                                         int length,
                                         E element)

rangedRemove

public static final <E> int rangedRemove(E[] data,
                                         int size,
                                         int offset,
                                         int length,
                                         E sample,
                                         Equalator<? super E> equalator)

rangedRemoveNull

public static final <E> int rangedRemoveNull(E[] data,
                                             int size,
                                             int offset,
                                             int length)

reduce

public static final <E> int reduce(E[] data,
                                   int size,
                                   Predicate<? super E> predicate,
                                   E removeMarker)

rangedReduce

public static final <E> int rangedReduce(E[] data,
                                         int size,
                                         int offset,
                                         int length,
                                         Predicate<? super E> predicate,
                                         E removeMarker)

retainAll

public static final <E> int retainAll(E[] data,
                                      int size,
                                      XGettingCollection<E> elements,
                                      E removeMarker)

rangedRetainAll

public static final <E> int rangedRetainAll(E[] data,
                                            int size,
                                            int offset,
                                            int length,
                                            XGettingCollection<E> elements,
                                            E removeMarker)

retainAll

public static final <E> int retainAll(E[] data,
                                      int size,
                                      XGettingCollection<E> samples,
                                      Equalator<? super E> equalator,
                                      E removeMarker)

rangedRetainAll

public static final <E> int rangedRetainAll(E[] data,
                                            int size,
                                            int offset,
                                            int length,
                                            XGettingCollection<E> samples,
                                            Equalator<? super E> equalator,
                                            E removeMarker)

process

public static final <E> int process(E[] data,
                                    int size,
                                    Consumer<? super E> procedure,
                                    E removeMarker)

rangedProcess

public static final <E> int rangedProcess(E[] data,
                                          int size,
                                          int offset,
                                          int length,
                                          Consumer<? super E> procedure,
                                          E removeMarker)

moveTo

public static final <E> int moveTo(E[] data,
                                   int size,
                                   Consumer<? super E> target,
                                   Predicate<? super E> predicate,
                                   E removeMarker)

rangedMoveTo

public static final <E> int rangedMoveTo(E[] data,
                                         int size,
                                         int offset,
                                         int length,
                                         Consumer<? super E> target,
                                         Predicate<? super E> predicate,
                                         E removeMarker)

moveSelection

public static final <E> int moveSelection(E[] data,
                                          int size,
                                          long[] indices,
                                          Consumer<? super E> target,
                                          E removeMarker)

rangedRemoveAll

public static final <E> int rangedRemoveAll(E[] data,
                                            int size,
                                            int offset,
                                            int length,
                                            XGettingCollection<? extends E> elements)

rangedRemoveAll

public static final <E> int rangedRemoveAll(E[] data,
                                            int size,
                                            int offset,
                                            int length,
                                            XGettingCollection<? extends E> samples,
                                            Equalator<? super E> equalator,
                                            E removeMarker)

removeDuplicates

public static final <E> int removeDuplicates(E[] data,
                                             int size,
                                             Equalator<? super E> equalator,
                                             E removeMarker)

rangedRemoveDuplicates

public static final <E> int rangedRemoveDuplicates(E[] data,
                                                   int size,
                                                   int offset,
                                                   int length,
                                                   Equalator<? super E> equalator,
                                                   E removeMarker)

removeDuplicates

public static final <E> int removeDuplicates(E[] data,
                                             int size,
                                             E removeMarker)

rangedRemoveDuplicates

public static final <E> int rangedRemoveDuplicates(E[] data,
                                                   int size,
                                                   int offset,
                                                   int length,
                                                   E removeMarker)

removeSelection

public static final <E> int removeSelection(E[] data,
                                            int size,
                                            long[] indices,
                                            E removeMarker)

removeRange

public static final <E> int removeRange(E[] data,
                                        int size,
                                        int offset,
                                        int length)

retainRange

public static final <E> int retainRange(E[] data,
                                        int size,
                                        int offset,
                                        int length)

retrieve

public static final <E> E retrieve(E[] data,
                                   int size,
                                   E element,
                                   E notFoundMarker)

retrieve

public static final <E> E retrieve(E[] data,
                                   int size,
                                   E sample,
                                   Equalator<? super E> equalator,
                                   E notFoundMarker)

retrieve

public static final <E> E retrieve(E[] data,
                                   int size,
                                   Predicate<? super E> predicate,
                                   E notFoundMarker)

removeOne

public static final <E> boolean removeOne(E[] data,
                                          int size,
                                          E element)

removeOne

public static final <E> boolean removeOne(E[] data,
                                          int size,
                                          E sample,
                                          Equalator<? super E> equalator)

rangedRetrieve

public static final <E> E rangedRetrieve(E[] data,
                                         int size,
                                         int offset,
                                         int length,
                                         E element,
                                         E notFoundMarker)

rangedRetrieve

public static final <E> E rangedRetrieve(E[] data,
                                         int size,
                                         int offset,
                                         int length,
                                         E sample,
                                         Equalator<? super E> equalator,
                                         E notFoundMarker)

rangedRetrieve

public static final <E> E rangedRetrieve(E[] data,
                                         int size,
                                         int offset,
                                         int length,
                                         Predicate<? super E> predicate,
                                         E notFoundMarker)

rangedRemoveOne

public static final <E> boolean rangedRemoveOne(E[] data,
                                                int size,
                                                int offset,
                                                int length,
                                                E element)

rangedRemoveOne

public static final <E> boolean rangedRemoveOne(E[] data,
                                                int size,
                                                int offset,
                                                int length,
                                                E sample,
                                                Equalator<? super E> equalator)

replaceOne

public static final <E> boolean replaceOne(E[] data,
                                           int size,
                                           E oldElement,
                                           E newElement)

rangedReplaceOne

public static final <E> int rangedReplaceOne(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             E oldElement,
                                             E newElement)

replaceOne

public static final <E> boolean replaceOne(E[] data,
                                           int size,
                                           E sample,
                                           E newElement,
                                           Equalator<? super E> equalator)

rangedReplaceOne

public static final <E> int rangedReplaceOne(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             E sample,
                                             E newElement,
                                             Equalator<? super E> equalator)

substituteOne

public static final <E> boolean substituteOne(E[] data,
                                              int size,
                                              Predicate<? super E> predicate,
                                              E replacement)

rangedReplaceOne

public static final <E> int rangedReplaceOne(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             Predicate<? super E> predicate,
                                             E newElement)

replace

public static final <E> int replace(E[] data,
                                    int size,
                                    E oldElement,
                                    E newElement)

rangedReplace

public static final <E> int rangedReplace(E[] data,
                                          int size,
                                          int offset,
                                          int length,
                                          E oldElement,
                                          E newElement)

replace

public static final <E> int replace(E[] data,
                                    int size,
                                    E sample,
                                    E newElement,
                                    Equalator<? super E> equalator)

rangedReplace

public static final <E> long rangedReplace(E[] data,
                                           int size,
                                           int offset,
                                           int length,
                                           E sample,
                                           E newElement,
                                           Equalator<? super E> equalator)

substitute

public static final <E> long substitute(E[] data,
                                        int size,
                                        Predicate<? super E> predicate,
                                        E newElement)

rangedReplace

public static final <E> int rangedReplace(E[] data,
                                          int size,
                                          int offset,
                                          int length,
                                          Predicate<? super E> predicate,
                                          E newElement)

replaceAll

public static final <E,U extends E> int replaceAll(E[] data,
                                                   int size,
                                                   XGettingCollection<U> oldElements,
                                                   E newElement,
                                                   E marker)

rangedReplaceAll

public static final <E> int rangedReplaceAll(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             XGettingCollection<E> oldElements,
                                             E newElement)

replaceAll

public static final <E,U extends E> int replaceAll(E[] data,
                                                   int size,
                                                   XGettingCollection<U> samples,
                                                   E newElement,
                                                   Equalator<? super E> equalator,
                                                   E marker)

rangedReplaceAll

public static final <E> int rangedReplaceAll(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             XGettingCollection<E> samples,
                                             E newElement,
                                             Equalator<? super E> equalator)

replaceAll

public static final <E> int replaceAll(E[] data,
                                       int size,
                                       XMap<E,E> replacementMapping)

substitute

public static final <E> long substitute(E[] data,
                                        int size,
                                        Function<? super E,? extends E> mapper)

substitute

public static final <E> long substitute(E[] data,
                                        int size,
                                        Predicate<? super E> predicate,
                                        Function<E,E> mapper)

rangedReplaceAll

public static final <E> int rangedReplaceAll(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             XMap<E,E> replacementMapping)

rangedModify

public static final <E> int rangedModify(E[] data,
                                         int size,
                                         int offset,
                                         int length,
                                         Function<E,E> mapper)

swap

public static final <E> void swap(E[] data,
                                  int size,
                                  int indexA,
                                  int indexB)
                           throws IndexOutOfBoundsException,
                                  ArrayIndexOutOfBoundsException

Throws:

IndexOutOfBoundsException

ArrayIndexOutOfBoundsException

swap

public static final <E> void swap(E[] data,
                                  int size,
                                  int indexA,
                                  int indexB,
                                  int length)

reverse

public static final <E> void reverse(E[] data,
                                     int size)

rangedReverse

public static final <E> void rangedReverse(E[] data,
                                           int size,
                                           int offset,
                                           int length)

set

public static final <E> void set(E[] data,
                                 int size,
                                 int offset,
                                 E[] elements)

set

public static final <E> void set(E[] data,
                                 int size,
                                 int offset,
                                 XGettingSequence<? extends E> elements,
                                 long elementsOffset,
                                 long elementsLength)

set

public static final <E> void set(E[] data,
                                 int size,
                                 int offset,
                                 E[] src,
                                 int srcIndex,
                                 int srcLength)

fill

public static final <E> void fill(E[] data,
                                  int size,
                                  int offset,
                                  int length,
                                  E element)

toString

public static final String toString(Object[] data,
                                    int size)

appendTo

public static final <E> VarString appendTo(E[] data,
                                           int size,
                                           VarString vc)

appendTo

public static final <E> VarString appendTo(E[] data,
                                           int size,
                                           VarString vc,
                                           char separator)

appendTo

public static final <E> VarString appendTo(E[] data,
                                           int size,
                                           VarString vc,
                                           String separator)

appendTo

public static final <E> VarString appendTo(E[] data,
                                           int size,
                                           VarString vc,
                                           BiConsumer<VarString,? super E> appender)

appendTo

public static final <E> VarString appendTo(E[] data,
                                           int size,
                                           VarString vc,
                                           BiConsumer<VarString,? super E> appender,
                                           char separator)

appendTo

public static final <E> VarString appendTo(E[] data,
                                           int size,
                                           VarString vc,
                                           BiConsumer<VarString,? super E> appender,
                                           String separator)

rangedAppendTo

public static final <E> VarString rangedAppendTo(E[] data,
                                                 int size,
                                                 int offset,
                                                 int length,
                                                 VarString vc)

rangedAppendTo

public static final <E> VarString rangedAppendTo(E[] data,
                                                 int size,
                                                 int offset,
                                                 int length,
                                                 VarString vc,
                                                 char separator)

rangedAppendTo

public static final <E> VarString rangedAppendTo(E[] data,
                                                 int size,
                                                 int offset,
                                                 int length,
                                                 VarString vc,
                                                 String separator)

rangedAppendTo

public static final <E> VarString rangedAppendTo(E[] data,
                                                 int size,
                                                 int offset,
                                                 int length,
                                                 VarString vc,
                                                 BiConsumer<VarString,? super E> appender)

rangedAppendTo

public static final <E> VarString rangedAppendTo(E[] data,
                                                 int size,
                                                 int offset,
                                                 int length,
                                                 VarString vc,
                                                 BiConsumer<VarString,? super E> appender,
                                                 char separator)

rangedAppendTo

public static final <E> VarString rangedAppendTo(E[] data,
                                                 int size,
                                                 int offset,
                                                 int length,
                                                 VarString vc,
                                                 BiConsumer<VarString,? super E> appender,
                                                 String separator)

isSorted

public static final <E> boolean isSorted(E[] data,
                                         int size,
                                         Comparator<? super E> comparator)

rangedIsSorted

public static final <E> boolean rangedIsSorted(E[] data,
                                               int size,
                                               int offset,
                                               int length,
                                               Comparator<? super E> comparator)

sortInsertion

public static final <E> void sortInsertion(E[] data,
                                           int size,
                                           Comparator<? super E> comparator)

rangedSortInsertion

public static final <E> void rangedSortInsertion(E[] data,
                                                 int size,
                                                 int offset,
                                                 int length,
                                                 Comparator<? super E> comparator)

rangedSortQuick

public static final <E> void rangedSortQuick(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             Comparator<? super E> comparator)

rangedSortMerge

public static final <E> void rangedSortMerge(E[] data,
                                             int size,
                                             int offset,
                                             int length,
                                             Comparator<? super E> comparator)

rangedSort

public static final <E> void rangedSort(E[] data,
                                        int size,
                                        int offset,
                                        int length,
                                        Comparator<? super E> comparator)

shuffle

public static final <E> void shuffle(E[] data,
                                     int size)

rangedShuffle

public static final <E> void rangedShuffle(E[] data,
                                           int size,
                                           int offset,
                                           int length)

toReversed

public static final <T> T[] toReversed(T[] array,
                                       int size)

hasDistinctValues

public static final <E> boolean hasDistinctValues(E[] data,
                                                  int size)

rangedHasUniqueValues

public static final <E> boolean rangedHasUniqueValues(E[] data,
                                                      int size,
                                                      int offset,
                                                      int length)

hasDistinctValues

public static final <E> boolean hasDistinctValues(E[] data,
                                                  int size,
                                                  Equalator<? super E> equalator)

hasDistinctValues

public static final <E> boolean hasDistinctValues(E[] data,
                                                  int size,
                                                  HashEqualator<? super E> equalator)

rangedHasUniqueValues

public static final <E> boolean rangedHasUniqueValues(E[] data,
                                                      int size,
                                                      int offset,
                                                      int length,
                                                      Equalator<? super E> equalator)

equalsContent

public static final <E> boolean equalsContent(E[] data,
                                              int size,
                                              Collection<? extends E> collection,
                                              Equalator<? super E> equalator)

equalsContent

public static final <E> boolean equalsContent(E[] data,
                                              int size,
                                              XGettingCollection<? extends E> samples,
                                              Equalator<? super E> equalator)

rangedEqualsContent

public static final <E> boolean rangedEqualsContent(E[] data,
                                                    int size,
                                                    int offset,
                                                    int length,
                                                    List<? extends E> list,
                                                    Equalator<? super E> equalator)

rangedEqualsContent

public static final <E> boolean rangedEqualsContent(E[] data,
                                                    int size,
                                                    int offset,
                                                    int length,
                                                    XGettingSequence<? extends E> sequence,
                                                    Equalator<? super E> equalator)

rangedToArray

public static final Object[] rangedToArray(Object[] data,
                                           int size,
                                           int offset,
                                           int length)

rangedToArray

public static final <T> T[] rangedToArray(Object[] data,
                                          int size,
                                          int offset,
                                          int length,
                                          T[] a)

rangedToArray

public static <E> E[] rangedToArray(E[] data,
                                    int size,
                                    int offset,
                                    int length,
                                    Class<E> type)

checkIterationDirection

@Deprecated
public static final int checkIterationDirection(int size,
                                                            int offset,
                                                            int length)

Deprecated.