1 files changed, 253 insertions, 0 deletions
diff --git a/javaparser-core/src/main/java/com/github/javaparser/utils/Utils.java b/javaparser-core/src/main/java/com/github/javaparser/utils/Utils.java
new file mode 100644
index 000000000..2db00e522
--- /dev/null
+++ b/javaparser-core/src/main/java/com/github/javaparser/utils/Utils.java
@@ -0,0 +1,253 @@
+/*
+ * 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;
+    }
+
+}