| /* |
| * Copyright (C) 2007-2010 JĂșlio Vilmar Gesser. |
| * Copyright (C) 2011, 2013-2016 The JavaParser Team. |
| * |
| * This file is part of JavaParser. |
| * |
| * JavaParser can be used either under the terms of |
| * a) the GNU Lesser General Public License as published by |
| * the Free Software Foundation, either version 3 of the License, or |
| * (at your option) any later version. |
| * b) the terms of the Apache License |
| * |
| * You should have received a copy of both licenses in LICENCE.LGPL and |
| * LICENCE.APACHE. Please refer to those files for details. |
| * |
| * JavaParser is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU Lesser General Public License for more details. |
| */ |
| |
| package com.github.javaparser.utils; |
| |
| import java.io.IOException; |
| import java.io.Reader; |
| import java.util.*; |
| import java.util.function.Predicate; |
| import java.util.function.Function; |
| |
| import static java.util.Arrays.*; |
| |
| /** |
| * Any kind of utility. |
| * |
| * @author Federico Tomassetti |
| */ |
| public class Utils { |
| public static final String EOL = System.getProperty("line.separator"); |
| |
| public static final Predicate<String> STRING_NOT_EMPTY = s -> !s.isEmpty(); |
| |
| /** |
| * @deprecated This is no longer in use by JavaParser, please write your own replacement. |
| */ |
| public static <T> List<T> ensureNotNull(List<T> list) { |
| return list == null ? new ArrayList<>() : list; |
| } |
| |
| public static <E> boolean isNullOrEmpty(Collection<E> collection) { |
| return collection == null || collection.isEmpty(); |
| } |
| |
| public static <T> T assertNotNull(T o) { |
| if (o == null) { |
| throw new AssertionError("A reference was unexpectedly null."); |
| } |
| return o; |
| } |
| |
| public static String assertNonEmpty(String string) { |
| if (string == null || string.isEmpty()) { |
| throw new AssertionError("A string was unexpectedly empty."); |
| } |
| return string; |
| } |
| |
| /** |
| * @return string with ASCII characters 10 and 13 replaced by the text "\n" and "\r". |
| */ |
| public static String escapeEndOfLines(String string) { |
| StringBuilder escapedString = new StringBuilder(); |
| for (char c : string.toCharArray()) { |
| switch (c) { |
| case '\n': |
| escapedString.append("\\n"); |
| break; |
| case '\r': |
| escapedString.append("\\r"); |
| break; |
| default: |
| escapedString.append(c); |
| } |
| } |
| return escapedString.toString(); |
| } |
| |
| public static String readerToString(Reader reader) throws IOException { |
| final StringBuilder result = new StringBuilder(); |
| final char[] buffer = new char[8 * 1024]; |
| int numChars; |
| |
| while ((numChars = reader.read(buffer, 0, buffer.length)) > 0) { |
| result.append(buffer, 0, numChars); |
| } |
| |
| return result.toString(); |
| } |
| |
| /** |
| * Puts varargs in a mutable list. |
| * This does not have the disadvantage of Arrays#asList that it has a static size. |
| * |
| * @deprecated This is no longer in use by JavaParser, please write your own replacement. |
| */ |
| @Deprecated |
| public static <T> List<T> arrayToList(T[] array) { |
| List<T> list = new LinkedList<>(); |
| Collections.addAll(list, array); |
| return list; |
| } |
| |
| /** |
| * @deprecated use screamingToCamelCase |
| */ |
| public static String toCamelCase(String original) { |
| return screamingToCamelCase(original); |
| } |
| |
| /** |
| * Transform a string to the camel case conversion. |
| * <p> |
| * For example "ABC_DEF" becomes "abcDef" |
| */ |
| public static String screamingToCamelCase(String original) { |
| StringBuilder sb = new StringBuilder(); |
| String[] parts = original.toLowerCase().split("_"); |
| for (int i = 0; i < parts.length; i++) { |
| sb.append(i == 0 ? parts[i] : capitalize(parts[i])); |
| } |
| return sb.toString(); |
| } |
| |
| |
| /** |
| * @param input "aCamelCaseString" |
| * @return "A_CAMEL_CASE_STRING" |
| */ |
| public static String camelCaseToScreaming(String input) { |
| if (input.isEmpty()) { |
| return ""; |
| } |
| StringBuilder scream = new StringBuilder(input.substring(0, 1).toUpperCase()); |
| for (char c : input.substring(1).toCharArray()) { |
| if (Character.isUpperCase(c)) { |
| scream.append("_"); |
| } |
| scream.append(Character.toUpperCase(c)); |
| } |
| return scream.toString(); |
| } |
| |
| /** |
| * Return the next word of the string, in other words it stops when a space is encountered. |
| */ |
| public static String nextWord(String string) { |
| int index = 0; |
| while (index < string.length() && !Character.isWhitespace(string.charAt(index))) { |
| index++; |
| } |
| return string.substring(0, index); |
| } |
| |
| /** |
| * Make an indent by appending indentLevel tab characters to the builder. |
| */ |
| public static StringBuilder indent(StringBuilder builder, int indentLevel) { |
| for (int i = 0; i < indentLevel; i++) { |
| builder.append("\t"); |
| } |
| return builder; |
| } |
| |
| /** |
| * Capitalizes the first character in the string. |
| */ |
| public static String capitalize(String s) { |
| return stringTransformer(s, "capitalize", String::toUpperCase); |
| } |
| |
| /** |
| * Lower-cases the first character in the string. |
| */ |
| public static String decapitalize(String s) { |
| return stringTransformer(s, "decapitalize", String::toLowerCase); |
| } |
| |
| private static String stringTransformer(String s, String operationDescription, Function<String, String> transformation) { |
| if (s.isEmpty()) { |
| throw new IllegalArgumentException(String.format("You cannot %s an empty string", operationDescription)); |
| } |
| return transformation.apply(s.substring(0, 1)) + |
| s.substring(1); |
| } |
| |
| /** |
| * @return true if the value is null, an empty Optional, or an empty String. |
| */ |
| public static boolean valueIsNullOrEmpty(Object value) { |
| if (value == null) { |
| return true; |
| } |
| if (value instanceof Optional) { |
| if (((Optional) value).isPresent()) { |
| value = ((Optional) value).get(); |
| } else { |
| return true; |
| } |
| } |
| if (value instanceof Collection) { |
| if (((Collection) value).isEmpty()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * @return a set of the items. |
| */ |
| public static <T> Set<T> set(T... items) { |
| return new HashSet<>(asList(items)); |
| } |
| |
| /** |
| * @return content with all kinds of EOL characters replaced by endOfLineCharacter |
| */ |
| public static String normalizeEolInTextBlock(String content, String endOfLineCharacter) { |
| return content |
| .replaceAll("\\R", endOfLineCharacter); |
| } |
| |
| /** |
| * @return the filename with the last "." and everything following it removed. |
| */ |
| public static String removeFileExtension(String filename) { |
| int extensionIndex = filename.lastIndexOf("."); |
| if (extensionIndex == -1) |
| return filename; |
| |
| return filename.substring(0, extensionIndex); |
| } |
| |
| /** |
| * Like {@link String#trim()}, but only the trailing spaces. |
| */ |
| public static String trimTrailingSpaces(String line) { |
| while (line.length() > 0 && line.charAt(line.length() - 1) <= 0x20) { |
| line = line.substring(0, line.length() - 1); |
| } |
| return line; |
| } |
| |
| } |