public LocalVariableTableEntry( final int index, final String name, final TypeReference type, final int scopeOffset, final int scopeLength) { _index = VerifyArgument.isNonNegative(index, "index"); _name = VerifyArgument.notNull(name, "name"); _type = VerifyArgument.notNull(type, "type"); _scopeOffset = VerifyArgument.isNonNegative(scopeOffset, "scopeOffset"); _scopeLength = VerifyArgument.isNonNegative(scopeLength, "scopeLength"); }
public static float[] insert(final float[] array, final int index, final float value) { VerifyArgument.notNull(array, "array"); VerifyArgument.inRange(0, array.length, index, "index"); final float[] newArray = new float[array.length + 1]; System.arraycopy(array, 0, newArray, 0, index); final int remaining = array.length - index; if (remaining > 0) { System.arraycopy(array, index, newArray, index + 1, remaining); } newArray[index] = value; return newArray; }
public static List<Range> invert(final Iterable<Range> input, final int codeSize) { VerifyArgument.notNull(input, "input"); VerifyArgument.isPositive(codeSize, "codeSize");
@SafeVarargs public static <T> T[] insert(final T[] array, final int index, final T... values) { VerifyArgument.notNull(array, "array"); VerifyArgument.inRange(0, array.length, index, "index"); if (values == null || values.length == 0) { return array; } VerifyArgument.elementsOfType(array.getClass().getComponentType(), values, "values"); final int newItemCount = values.length; final T[] newArray = (T[])Array.newInstance( array.getClass().getComponentType(), array.length + newItemCount ); System.arraycopy(array, 0, newArray, 0, index); final int remaining = array.length - index; if (remaining > 0) { System.arraycopy(array, index, newArray, index + newItemCount, remaining); } System.arraycopy(values, 0, newArray, index, newItemCount); return newArray; }
@SuppressWarnings("unchecked") public static <T> T notInstanceOf(final Class<T> type, final Object value, final String parameterName) { final Class<?> actualType = getBoxedType(VerifyArgument.notNull(type, "type")); if (!actualType.isInstance(value)) { return (T) value; } throw new IllegalArgumentException( format( "Argument '%s' must not be an instance of type %s.", parameterName, type.getCanonicalName() ) ); }
private ClassSignature( final TypeReference baseType, final List<TypeReference> interfaceTypes, final List<GenericParameter> genericParameters) { _baseType = VerifyArgument.notNull(baseType, "baseType"); _interfaceTypes = VerifyArgument.noNullElements(interfaceTypes, "interfaceTypes"); _genericParameters = VerifyArgument.noNullElements(genericParameters, "genericParameters"); }
public static int[] range(final int start, final int count) { VerifyArgument.isNonNegative(count, "count"); if (count == 0) { return EmptyArrayCache.EMPTY_INT_ARRAY; } final int[] array = new int[count]; for (int i = 0, j = start; i < array.length; i++) { array[i] = j++; } return array; }
private static int computeInitialCapacity(final int initialCapacity, final float loadFactor) { VerifyArgument.isNonNegative(initialCapacity, "initialCapacity"); VerifyArgument.isPositive(loadFactor, "loadFactor"); final int desiredCapacity = Math.min(initialCapacity, MAXIMUM_CAPACITY); int capacity = 1; while (capacity < desiredCapacity) { capacity <<= 1; } return capacity; }
public static Type<?> makeCompoundType(final TypeList bounds) { VerifyArgument.notEmpty(bounds, "bounds"); VerifyArgument.noNullElements(bounds, "bounds"); final Type<?> baseType; final TypeList interfaces; if (!bounds.get(0).isInterface()) { baseType = bounds.get(0); interfaces = bounds.subList(1, bounds.size()); } else { baseType = Types.Object; interfaces = bounds; } return makeCompoundType(baseType, interfaces); }
@SuppressWarnings("unchecked") public <T extends Entry> T getEntry(final int index) { VerifyArgument.inRange(0, _size + 1, index, "index"); final Entry info = _pool.get(index - 1); if (info == null) { throw new IndexOutOfBoundsException(); } return (T) info; }
public static <T> T[] noNullElementsAndNotEmpty(final T[] array, final String parameterName) { notEmpty(array, parameterName); for (final T item : array) { if (item == null) { throw new IllegalArgumentException( format("Argument '%s' must not have any null elements.", parameterName) ); } } return array; }
public static TypeBindings create(final TypeList genericParameters, final TypeList boundTypes) { return new TypeBindings( VerifyArgument.noNullElements(genericParameters, "genericParameters"), VerifyArgument.noNullElements(boundTypes, "boundTypes") ); }
public LocalVariableTableEntry( final int index, final String name, final TypeReference type, final int scopeOffset, final int scopeLength) { _index = VerifyArgument.isNonNegative(index, "index"); _name = VerifyArgument.notNull(name, "name"); _type = VerifyArgument.notNull(type, "type"); _scopeOffset = VerifyArgument.isNonNegative(scopeOffset, "scopeOffset"); _scopeLength = VerifyArgument.isNonNegative(scopeLength, "scopeLength"); }
public static boolean[] insert(final boolean[] array, final int index, final boolean value) { VerifyArgument.notNull(array, "array"); VerifyArgument.inRange(0, array.length, index, "index"); final boolean[] newArray = new boolean[array.length + 1]; System.arraycopy(array, 0, newArray, 0, index); final int remaining = array.length - index; if (remaining > 0) { System.arraycopy(array, index, newArray, index + 1, remaining); } newArray[index] = value; return newArray; }
public static List<Range> invert(final Iterable<Range> input, final int codeSize) { VerifyArgument.notNull(input, "input"); VerifyArgument.isPositive(codeSize, "codeSize");
@SafeVarargs public static <T> T[] insert(final T[] array, final int index, final T... values) { VerifyArgument.notNull(array, "array"); VerifyArgument.inRange(0, array.length, index, "index"); if (values == null || values.length == 0) { return array; } VerifyArgument.elementsOfType(array.getClass().getComponentType(), values, "values"); final int newItemCount = values.length; final T[] newArray = (T[])Array.newInstance( array.getClass().getComponentType(), array.length + newItemCount ); System.arraycopy(array, 0, newArray, 0, index); final int remaining = array.length - index; if (remaining > 0) { System.arraycopy(array, index, newArray, index + newItemCount, remaining); } System.arraycopy(values, 0, newArray, index, newItemCount); return newArray; }
@SuppressWarnings("unchecked") public static <T> T instanceOf(final Class<T> type, final Object value, final String parameterName) { final Class<?> actualType = getBoxedType(VerifyArgument.notNull(type, "type")); if (actualType.isInstance(value)) { return (T) value; } throw new IllegalArgumentException( format( "Argument '%s' must be an instance of type %s.", parameterName, type.getCanonicalName() ) ); } @SuppressWarnings("unchecked")
public static Type<?> makeCompoundType(final Type<?> baseType, final TypeList interfaces) { VerifyArgument.notNull(baseType, "baseType"); VerifyArgument.noNullElements(interfaces, "interfaces"); return makeCompoundTypeCore(baseType, interfaces); }
public static int[] range(final int start, final int count) { VerifyArgument.isNonNegative(count, "count"); if (count == 0) { return EmptyArrayCache.EMPTY_INT_ARRAY; } final int[] array = new int[count]; for (int i = 0, j = start; i < array.length; i++) { array[i] = j++; } return array; }