@Override public void addColumnName(String columnName) { this.columnNames = ArrayUtil.append(columnName, columnNames); }
public E[] toArray() { E[] result = ArrayUtil.newInstance(componentType, elementCount); System.arraycopy(buffer, 0, result, 0, elementCount); elementCount = 0; buffer = null; return result; }
protected Object parent(E[] parentPath) { if (ArrayUtil.isEmpty(parentPath)) return null; else return ArrayUtil.lastElementOf(parentPath); }
@SuppressWarnings("unchecked") public E[] createSubPath(E[] parentPath, E currentObject) { if (parentPath == null) return ArrayUtil.buildObjectArrayOfType(pathComponentType, currentObject); else return ArrayUtil.append(currentObject, parentPath); }
public static boolean typesMatch(Class<?>[] usedTypes, Class<?>[] expectedTypes) { if (ArrayUtil.isEmpty(expectedTypes)) return ArrayUtil.isEmpty(usedTypes); Class<?> lastExpectedType = ArrayUtil.lastElementOf(expectedTypes); if (lastExpectedType.isArray()) { return false; // fault if (usedTypes.length == expectedTypes.length - 1) return typesMatch(usedTypes, ArrayUtil.copyOfRange(expectedTypes, 0, usedTypes.length)); // empty varargs
public static <T> boolean containsAll(T[] subArray, T[] superArray) { for (T t : subArray) if (!contains(t, superArray)) return false; return true; }
public static <T> T lastElementOf(T[] array) { if (isEmpty(array)) return null; return array[array.length - 1]; }
@SuppressWarnings("unchecked") public static <T> T[] append(T value, T[] array) { if (array == null) { return toArray(value); } else { T[] newArray = newInstance(componentType(array), array.length + 1); System.arraycopy(array, 0, newArray, 0, array.length); newArray[array.length] = value; return newArray; } }
@Override public boolean supports(Element element, E[] parentPath) { if (!this.elementName.equals(element.getNodeName())) return false; return CollectionUtil.isEmpty(this.supportedParentTypes) || parentPath == null || this.supportedParentTypes.contains(ArrayUtil.lastElementOf(parentPath).getClass()); }
public static <T> T[] cloneAll(T[] input) { T[] output = ArrayUtil.newInstance(ArrayUtil.componentType(input), input.length); for (int i = 0; i < input.length; i++) output[i] = clone(input[i]); return output; }
public static <T> T[] removeAll(T[] toRemove, T[] target) { Class<T> componentType = componentType(target); ArrayBuilder<T> builder = new ArrayBuilder<T>(componentType); for (T element : target) if (!contains(element, toRemove)) builder.add(element); return builder.toArray(); }
public static <T> T[] copyOfRange(T[] array, int offset, int length) { return copyOfRange(array, offset, length, componentType(array)); }
@SuppressWarnings("unchecked") public static <T> T[] toArray(T... values) { Class<T> componentType = (Class<T>) (values.length > 0 ? values[0].getClass() : Object.class); return buildObjectArrayOfType(componentType, values); }
public static int indexOf(byte[] subArray, byte[] array) { return indexOf(subArray, 0, array); }
private static String[] parseHeaders(String uri, String sheetName, XLSLineIterator iterator) { // get headers String[] headers = iterator.getHeaders(); Assert.notEmpty(headers, "Empty XLS sheet '" + sheetName + "' in document " + uri); // normalize headers for (int i = 0; i < headers.length; i++) headers[i] = StringUtil.trimmedEmptyToNull(headers[i]); // determine trailing empty headers int headerCount = headers.length; while (headers[headerCount - 1] == null && headerCount > 0) headerCount--; // verify the regular headers if (headerCount == 0) throw new IllegalArgumentException("No headers in XLS sheet '" + sheetName + "' of document " + uri); for (int i = 0; i < headerCount; i++) Assert.notNull(headers[i], "Empty header in column #" + i + " of sheet '" + sheetName + "' of file '" + uri + "'"); // remove trailing empty headers return ArrayUtil.copyOfRange(headers, 0, headerCount); }
protected Object parent(E[] parentPath) { if (ArrayUtil.isEmpty(parentPath)) return null; else return ArrayUtil.lastElementOf(parentPath); }
@SuppressWarnings("unchecked") public E[] createSubPath(E[] parentPath, E currentObject) { if (parentPath == null) return ArrayUtil.buildObjectArrayOfType(pathComponentType, currentObject); else return ArrayUtil.append(currentObject, parentPath); }
public static <T> boolean equalsIgnoreOrder(T[] a1, T[] a2) { if (a1 == a2) return true; if (a1 == null) return false; if (a1.length != a2.length) return false; List<T> l1 = new ArrayList<T>(a1.length); for (T item : a1) l1.add(item); for (int i = a1.length - 1; i >= 0; i--) if (contains(a1[i], a2)) l1.remove(i); else return false; return l1.size() == 0; }