public void addAll(E[] elements) { for (E element : elements) add(element); }
private static void buildPath(Node node, ArrayBuilder<Node> list) { final Node parent = node.getParentNode(); if (parent != null) buildPath(parent, list); list.add(node); }
/** @deprecated replaced with add(Element) * @param element the element to append * @return this */ @Deprecated public ArrayBuilder<E> append(E element) { escalator.escalate(getClass().getName() + ".append() is deprecated, please use the add() method", getClass(), null); return add(element); }
public void addIfNotContained(E element) { if (!contains(element)) add(element); }
public static Method[] findMethodsByAnnotation( Class<?> owner, Class<? extends Annotation> annotationClass) { Method[] methods = owner.getMethods(); ArrayBuilder<Method> builder = new ArrayBuilder<Method>(Method.class); for (Method method : methods) if (method.getAnnotation(annotationClass) != null) builder.add(method); return builder.toArray(); }
public static Element[] toElementArray(NodeList nodeList) { if (nodeList == null) return new Element[0]; int n = nodeList.getLength(); ArrayBuilder<Element> builder = new ArrayBuilder<Element>(Element.class, n); for (int i = 0; i < n; i++) { Node item = nodeList.item(i); if (item instanceof Element) builder.add((Element) item); } return builder.toArray(); }
public static <T> T[] parse(String source, String separator, Class<T> componentType) { ArrayBuilder<T> builder = new ArrayBuilder<T>(componentType); int i = 0; int sepIndex; while ((sepIndex = source.indexOf(separator, i)) >= 0) { String token = source.substring(i, sepIndex); builder.add(AnyConverter.convert(token, componentType)); i = sepIndex + separator.length(); } builder.add(AnyConverter.convert(source.substring(i, source.length()), componentType)); return builder.toArray(); }
public static Method[] findMethodsByName(Class<?> type, String methodName) { ArrayBuilder<Method> builder = new ArrayBuilder<Method>(Method.class); for (Method method : type.getMethods()) { if (methodName.equals(method.getName())) builder.add(method); } return builder.toArray(); }
public static void invoke(String goal, File folder, boolean online) { ArrayBuilder<String> cmdBuilder = new ArrayBuilder<String>(String.class); // maven invocation if (SystemInfo.isWindows()) cmdBuilder.add("mvn.bat"); else cmdBuilder.add("mvn"); // offline parameter? if (!online) cmdBuilder.add("-o"); // goal cmdBuilder.add(goal); // run ShellUtil.runShellCommand(cmdBuilder.toArray(), null, folder, new ErrorHandler(MavenUtil.class)); }
public static Comment[] getChildComments(Node parent) { NodeList children; if (parent instanceof Document) children = ((Document) parent).getChildNodes(); else if (parent instanceof Element) children = ((Element) parent).getChildNodes(); else throw new UnsupportedOperationException("Not a supported type: " + parent.getClass()); ArrayBuilder<Comment> builder = new ArrayBuilder<Comment>(Comment.class); for (int i = 0; i < children.getLength(); i++) { Node child = children.item(i); if (child instanceof Comment) builder.add((Comment) child); } return builder.toArray(); }
public static String[] readTextLines(String uri, boolean includeEmptyLines) throws IOException { ArrayBuilder<String> builder = new ArrayBuilder<String>(String.class, 100); BufferedReader reader = getReaderForURI(uri); String line; while ((line = reader.readLine()) != null) if (line.length() > 0 || includeEmptyLines) builder.add(line); return builder.toArray(); }
public static Element[] getChildElements(Element parent, boolean namespaceAware, String name) { ArrayBuilder<Element> builder = new ArrayBuilder<Element>(Element.class); NodeList childNodes = parent.getChildNodes(); if (childNodes == null) return new Element[0]; int n = childNodes.getLength(); for (int i = 0; i < n; i++) { Node item = childNodes.item(i); if (item instanceof Element && hasName(name, namespaceAware, item)) builder.add((Element) item); } return builder.toArray(); }
public static <T> T[] queryScalarRowsAsArray(String query, Class<T> componentType, Connection connection) { Statement statement = null; ResultSet resultSet = null; try { statement = connection.createStatement(); resultSet = statement.executeQuery(query); ArrayBuilder<T> builder = new ArrayBuilder<T>(componentType); while (resultSet.next()) builder.add(AnyConverter.convert(resultSet.getObject(1), componentType)); return builder.toArray(); } catch (SQLException e) { throw new RuntimeException("Database query failed: " + query, e); } finally { closeResultSetAndStatement(resultSet, statement); } }
@Override public Object[] convert(Object[] raw) { NKBuilder nkBuilder = new NKBuilder(); for (int i = 0; i < columnNames.length; i++) { Object value = raw[i]; nkBuilder.addComponent(value); } ArrayBuilder<Object> arrayBuilder = new ArrayBuilder<Object>(Object.class); arrayBuilder.add(nkBuilder.toString()); for (int i = columnNames.length; i < raw.length; i++) arrayBuilder.add(raw[i]); return arrayBuilder.toArray(); }
public static String[] parseCSVRow(String text) { ArrayBuilder<String> builder = new ArrayBuilder<String>(String.class); CSVTokenizer tokenizer = new CSVTokenizer(new StringReader(text)); try { CSVTokenType type; while ((type = tokenizer.next()) != CSVTokenType.EOL && type != CSVTokenType.EOF) builder.add(tokenizer.cell); return builder.toArray(); } catch (IOException e) { throw new RuntimeException("Error parsing CSV row: " + text, e); } finally { IOUtil.close(tokenizer); } }
@Override public DBSequence[] querySequences(Connection connection) throws SQLException { String query = "select RDB$GENERATOR_NAME, RDB$GENERATOR_ID, RDB$SYSTEM_FLAG, RDB$DESCRIPTION " + "from RDB$GENERATORS where RDB$GENERATOR_NAME NOT LIKE '%$%'"; ResultSet resultSet = null; try { resultSet = DBUtil.executeQuery(query, connection); ArrayBuilder<DBSequence> builder = new ArrayBuilder<DBSequence>(DBSequence.class); while (resultSet.next()) builder.add(new DBSequence(resultSet.getString(1).trim(), null)); return builder.toArray(); } finally { DBUtil.closeResultSetAndStatement(resultSet); } }
@Override public DBSequence[] querySequences(Connection connection) throws SQLException { String query = "select SEQUENCE_CATALOG, SEQUENCE_SCHEMA, SEQUENCE_NAME, CURRENT_VALUE, INCREMENT, CACHE from information_schema.sequences"; // TODO v0.8.2 restrict to catalog and schema, see http://www.h2database.com/html/grammar.html ArrayBuilder<DBSequence> builder = new ArrayBuilder<DBSequence>(DBSequence.class); ResultSet resultSet = DBUtil.executeQuery(query, connection); while (resultSet.next()) { String name = resultSet.getString("SEQUENCE_NAME"); DBSequence sequence = new DBSequence(name, null); sequence.setStart(new BigInteger(resultSet.getString("CURRENT_VALUE"))); sequence.setLastNumber(sequence.getStart()); sequence.setIncrement(new BigInteger(resultSet.getString("INCREMENT"))); sequence.setCache(resultSet.getLong("CACHE")); builder.add(sequence); } return builder.toArray(); }
public static <T> T[] commonElements(Class<T> componentType, T[]... sources) { ArrayBuilder<T> builder = new ArrayBuilder<T>(componentType); T[] firstArray = sources[0]; for (T element : firstArray) { boolean common = true; for (int i = 1; i < sources.length; i++) if (!ArrayUtil.contains(element, sources[i])) { common = false; break; } if (common) builder.add(element); } return builder.toArray(); }
@SuppressWarnings("rawtypes") private static Expression<?>[] convertArguments(CommonTree node) { ArrayBuilder<Expression> result = new ArrayBuilder<Expression>(Expression.class); for (CommonTree child : getChildNodes(node)) result.add(convertExpressionNode(child)); return result.toArray(); }
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(); }