mods.thecomputerizer.theimpossiblelibrary.api.core

Class ArrayHelper

java.lang.Object

mods.thecomputerizer.theimpossiblelibrary.api.core.ArrayHelper

public class ArrayHelper
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
ArrayHelper()

Method Summary

Modifier and Type	Method and Description
static <T> T[]	append(T[] original, T toAppend, boolean allowDuplicates)
static <E> boolean	contains(E[] array, E value)
static int	countOccurrences(java.lang.Object array, java.lang.Object occurance)
static <T> T[]	create(java.lang.Class<T> clazz, int length) Creates an array with the input dimensions.
static <T> T[]	createMulti(java.lang.Class<T> clazz, int[] lengths) Creates a potentially multidimensional array with the input dimensions.
static <T> T[]	deduplicate(T[] array, boolean replaceValues, T replacement, T... valuesToIgnore) Removes all duplicate values from the input array.
static <T> T[]	deduplicate(T[] array, T... valuesToIgnore) Removes all duplicate values from the input array.
static <T> T[]	expand(T[] original, java.lang.Class<T> clazz) Increases the size of the array by 1.
static <E> int	findFirstOccurrence(E[] array, E element) Returns -1 if the element is not found in the array
static <E> int	findFirstOccurrenceAfter(E[] array, E element, int index) Returns -1 if the element is not found in the array after the index
static boolean[]	fixBoxedPrimitive(java.lang.Boolean... boxed) Probably should be avoided but serves as an easy way to unbox Boolean arrays
static byte[]	fixBoxedPrimitive(java.lang.Byte... boxed) Probably should be avoided but serves as an easy way to unbox Boolean arrays
static char[]	fixBoxedPrimitive(java.lang.Character... boxed) Probably should be avoided but serves as an easy way to unbox Character arrays
static double[]	fixBoxedPrimitive(java.lang.Double... boxed) Probably should be avoided but serves as an easy way to unbox Double arrays
static float[]	fixBoxedPrimitive(java.lang.Float... boxed) Probably should be avoided but serves as an easy way to unbox Float arrays
static int[]	fixBoxedPrimitive(java.lang.Integer... boxed) Probably should be avoided but serves as an easy way to unbox Integer arrays
static long[]	fixBoxedPrimitive(java.lang.Long... boxed) Probably should be avoided but serves as an easy way to unbox Long arrays
static short[]	fixBoxedPrimitive(java.lang.Short... boxed) Probably should be avoided but serves as an easy way to unbox Short arrays
static <E> E[]	fixObjParsed(java.lang.Object[] array, java.lang.Class<?> fixAs)
static <E> E[]	forEach(E[] array, java.util.function.BiConsumer<E,java.lang.Integer> consumer)
static <T> T[]	fromIterable(java.lang.Iterable<?> itr, java.lang.Class<T> clazz)
static <T> T[]	fromIterator(java.util.Iterator<?> itr, java.lang.Class<T> clazz)
static <E> boolean	hasElement(E[] array, E element)
static <E> boolean	hasElementAfter(E[] array, E element, int index)
static <E> boolean	hasElementExceptAt(E[] array, E element, int index)
static int[]	intRange(int min, int max)
static int[]	intRange(int min, int max, boolean inclusive)
static <E> boolean	isEmpty(E[] array)
static <E> boolean	isNotEmpty(E[] array)
static <E,T> T[]	mapTo(E[] array, java.lang.Class<T> clazz, java.util.function.Function<E,T> remapper)
static boolean	matches(@Nullable java.lang.Object[] array, @Nullable java.lang.Object other) Runs non-strict equality rules.
static boolean	matchesArray(@Nullable java.lang.Object[] array, @Nullable java.lang.Object[] other)
static <E> E[]	removeAllOccurrencesAfter(E[] array, E element, int after)
static <E> E[]	removeAllOccurrencesOf(E[] array, E element)
static <E> E[]	removeElement(E[] array, int index)
static <E> E[]	removeMatching(E[] array, E toMatch, java.util.function.Function<E,java.lang.Boolean> matcher)
static <E,F> void	supplyArray(E[] array, F thing, java.util.function.BiFunction<F,java.lang.Integer,E> func)
static <E> void	supplyArray(E[] array, java.util.function.Function<java.lang.Integer,E> func)
static <E,F> java.lang.Object	supplyArrayCreation(java.lang.Class<E> clazz, int size, F thing, java.util.function.BiFunction<F,java.lang.Integer,?> func)
static <E> java.lang.Object	supplyArrayCreation(java.lang.Class<E> clazz, int size, java.util.function.Function<java.lang.Integer,?> func)

Methods inherited from class java.lang.Object

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

Constructor Detail

ArrayHelper

public ArrayHelper()

Method Detail

append

public static <T> T[] append(T[] original,
                             T toAppend,
                             boolean allowDuplicates)

contains

public static <E> boolean contains(E[] array,
                                   E value)

countOccurrences

public static int countOccurrences(java.lang.Object array,
                                   java.lang.Object occurance)

create

public static <T> T[] create(java.lang.Class<T> clazz,
                             int length)

Creates an array with the input dimensions. Ensures the length is at least 0.

createMulti

public static <T> T[] createMulti(java.lang.Class<T> clazz,
                                  int[] lengths)

Creates a potentially multidimensional array with the input dimensions. Return nulls if an exception is caught

deduplicate

@SafeVarargs
public static <T> T[] deduplicate(T[] array,
                                                T... valuesToIgnore)

Removes all duplicate values from the input array.

deduplicate

@SafeVarargs
public static <T> T[] deduplicate(T[] array,
                                                boolean replaceValues,
                                                T replacement,
                                                T... valuesToIgnore)

Removes all duplicate values from the input array. If replaceValues is enabled, any duplicate values after the first instance will be replaced with the input replacement.

expand

public static <T> T[] expand(T[] original,
                             java.lang.Class<T> clazz)

Increases the size of the array by 1. The new element will be null or the default value for primitives. Calling this with an original that is null or has a length of 0 will still return an array with one element.

findFirstOccurrence

public static <E> int findFirstOccurrence(E[] array,
                                          E element)

Returns -1 if the element is not found in the array

findFirstOccurrenceAfter

public static <E> int findFirstOccurrenceAfter(E[] array,
                                               E element,
                                               int index)

Returns -1 if the element is not found in the array after the index

fixBoxedPrimitive

public static boolean[] fixBoxedPrimitive(java.lang.Boolean... boxed)

Probably should be avoided but serves as an easy way to unbox Boolean arrays

fixBoxedPrimitive

public static byte[] fixBoxedPrimitive(java.lang.Byte... boxed)

Probably should be avoided but serves as an easy way to unbox Boolean arrays

fixBoxedPrimitive

public static char[] fixBoxedPrimitive(java.lang.Character... boxed)

Probably should be avoided but serves as an easy way to unbox Character arrays

fixBoxedPrimitive

public static double[] fixBoxedPrimitive(java.lang.Double... boxed)

Probably should be avoided but serves as an easy way to unbox Double arrays

fixBoxedPrimitive

public static float[] fixBoxedPrimitive(java.lang.Float... boxed)

Probably should be avoided but serves as an easy way to unbox Float arrays

fixBoxedPrimitive

public static int[] fixBoxedPrimitive(java.lang.Integer... boxed)

Probably should be avoided but serves as an easy way to unbox Integer arrays

fixBoxedPrimitive

public static long[] fixBoxedPrimitive(java.lang.Long... boxed)

Probably should be avoided but serves as an easy way to unbox Long arrays

fixBoxedPrimitive

public static short[] fixBoxedPrimitive(java.lang.Short... boxed)

Probably should be avoided but serves as an easy way to unbox Short arrays

fixObjParsed

public static <E> E[] fixObjParsed(java.lang.Object[] array,
                                   java.lang.Class<?> fixAs)

forEach

public static <E> E[] forEach(E[] array,
                              java.util.function.BiConsumer<E,java.lang.Integer> consumer)

fromIterable

public static <T> T[] fromIterable(java.lang.Iterable<?> itr,
                                   java.lang.Class<T> clazz)

fromIterator

public static <T> T[] fromIterator(java.util.Iterator<?> itr,
                                   java.lang.Class<T> clazz)

hasElement

public static <E> boolean hasElement(E[] array,
                                     E element)

hasElementAfter

public static <E> boolean hasElementAfter(E[] array,
                                          E element,
                                          int index)

hasElementExceptAt

public static <E> boolean hasElementExceptAt(E[] array,
                                             E element,
                                             int index)

intRange

public static int[] intRange(int min,
                             int max)

intRange

public static int[] intRange(int min,
                             int max,
                             boolean inclusive)

isEmpty

public static <E> boolean isEmpty(E[] array)

isNotEmpty

public static <E> boolean isNotEmpty(E[] array)

mapTo

public static <E,T> T[] mapTo(E[] array,
                              java.lang.Class<T> clazz,
                              java.util.function.Function<E,T> remapper)

matches

public static boolean matches(@Nullable
                              @Nullable java.lang.Object[] array,
                              @Nullable
                              @Nullable java.lang.Object other)

Runs non-strict equality rules. If both inputs are null, they are considered matching. If the value is an instance of an array, iterable, or iterator, further matching rules are applied. If the array only has one element that matches the value, they are considered matching

matchesArray

public static boolean matchesArray(@Nullable
                                   @Nullable java.lang.Object[] array,
                                   @Nullable
                                   @Nullable java.lang.Object[] other)

removeAllOccurrencesAfter

public static <E> E[] removeAllOccurrencesAfter(E[] array,
                                                E element,
                                                int after)

removeAllOccurrencesOf

public static <E> E[] removeAllOccurrencesOf(E[] array,
                                             E element)

removeElement

public static <E> E[] removeElement(E[] array,
                                    int index)

removeMatching

public static <E> E[] removeMatching(E[] array,
                                     E toMatch,
                                     java.util.function.Function<E,java.lang.Boolean> matcher)

supplyArray

public static <E> void supplyArray(E[] array,
                                   java.util.function.Function<java.lang.Integer,E> func)

supplyArray

public static <E,F> void supplyArray(E[] array,
                                     F thing,
                                     java.util.function.BiFunction<F,java.lang.Integer,E> func)

supplyArrayCreation

public static <E> java.lang.Object supplyArrayCreation(java.lang.Class<E> clazz,
                                                       int size,
                                                       java.util.function.Function<java.lang.Integer,?> func)

supplyArrayCreation

public static <E,F> java.lang.Object supplyArrayCreation(java.lang.Class<E> clazz,
                                                         int size,
                                                         F thing,
                                                         java.util.function.BiFunction<F,java.lang.Integer,?> func)