diff options
Diffstat (limited to 'org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java')
| -rw-r--r-- | org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java | 329 |
1 files changed, 268 insertions, 61 deletions
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java index 2bfeaf1166..e381a3bcc9 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java @@ -1,44 +1,11 @@ /* - * Copyright (C) 2009-2010, Google Inc. - * and other copyright owners as documented in the project's IP log. + * Copyright (C) 2009-2022, Google Inc. and others * - * This program and the accompanying materials are made available - * under the terms of the Eclipse Distribution License v1.0 which - * accompanies this distribution, is reproduced below, and is - * available at http://www.eclipse.org/org/documents/edl-v10.php + * This program and the accompanying materials are made available under the + * terms of the Eclipse Distribution License v. 1.0 which is available at + * https://www.eclipse.org/org/documents/edl-v10.php. * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or - * without modification, are permitted provided that the following - * conditions are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * - Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * - * - Neither the name of the Eclipse Foundation, Inc. nor the - * names of its contributors may be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND - * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-3-Clause */ package org.eclipse.jgit.util; @@ -46,10 +13,24 @@ package org.eclipse.jgit.util; import java.text.MessageFormat; import java.util.Collection; +import org.eclipse.jgit.annotations.NonNull; +import org.eclipse.jgit.annotations.Nullable; import org.eclipse.jgit.internal.JGitText; +import org.eclipse.jgit.lib.Constants; -/** Miscellaneous string comparison utility methods. */ +/** + * Miscellaneous string comparison utility methods. + */ public final class StringUtils { + + private static final String EMPTY = ""; //$NON-NLS-1$ + + private static final long KiB = 1024; + + private static final long MiB = 1024 * KiB; + + private static final long GiB = 1024 * MiB; + private static final char[] LC; static { @@ -60,6 +41,10 @@ public final class StringUtils { LC[c] = (char) ('a' + (c - 'A')); } + private StringUtils() { + // Do not create instances + } + /** * Convert the input to lowercase. * <p> @@ -72,7 +57,7 @@ public final class StringUtils { * the input character. * @return lowercase version of the input. */ - public static char toLowerCase(final char c) { + public static char toLowerCase(char c) { return c <= 'Z' ? LC[c] : c; } @@ -89,7 +74,7 @@ public final class StringUtils { * @return a copy of the input string, after converting characters in the * range 'A'..'Z' to 'a'..'z'. */ - public static String toLowerCase(final String in) { + public static String toLowerCase(String in) { final StringBuilder r = new StringBuilder(in.length()); for (int i = 0; i < in.length(); i++) r.append(toLowerCase(in.charAt(i))); @@ -102,10 +87,12 @@ public final class StringUtils { * * <p> * Capitalizes a String changing the first letter to title case as per - * {@link Character#toTitleCase(char)}. No other letters are changed. + * {@link java.lang.Character#toTitleCase(char)}. No other letters are + * changed. + * </p> + * <p> + * A <code>null</code> input String returns <code>null</code>. * </p> - * - * A <code>null</code> input String returns <code>null</code>.</p> * * @param str * the String to capitalize, may be null @@ -117,7 +104,7 @@ public final class StringUtils { if (str == null || (strLen = str.length()) == 0) { return str; } - return new StringBuffer(strLen) + return new StringBuilder(strLen) .append(Character.toTitleCase(str.charAt(0))) .append(str.substring(1)).toString(); } @@ -134,9 +121,10 @@ public final class StringUtils { * second string to compare. * @return true if a equals b */ - public static boolean equalsIgnoreCase(final String a, final String b) { - if (a == b) + public static boolean equalsIgnoreCase(String a, String b) { + if (References.isSameObject(a, b)) { return true; + } if (a.length() != b.length()) return false; for (int i = 0; i < a.length(); i++) { @@ -156,9 +144,8 @@ public final class StringUtils { * first string to compare. * @param b * second string to compare. - * @return negative, zero or positive if a sorts before, is equal to, or - * sorts after b. * @since 2.0 + * @return an int. */ public static int compareIgnoreCase(String a, String b) { for (int i = 0; i < a.length() && i < b.length(); i++) { @@ -179,9 +166,8 @@ public final class StringUtils { * first string to compare. * @param b * second string to compare. - * @return negative, zero or positive if a sorts before, is equal to, or - * sorts after b. * @since 2.0 + * @return an int. */ public static int compareWithCase(String a, String b) { for (int i = 0; i < a.length() && i < b.length(); i++) { @@ -198,12 +184,12 @@ public final class StringUtils { * * @param stringValue * the string to parse. - * @return the boolean interpretation of {@code value}. - * @throws IllegalArgumentException - * if {@code value} is not recognized as one of the standard + * @return the boolean interpretation of {@code stringValue}. + * @throws java.lang.IllegalArgumentException + * if {@code stringValue} is not recognized as one of the standard * boolean names. */ - public static boolean toBoolean(final String stringValue) { + public static boolean toBoolean(String stringValue) { if (stringValue == null) throw new NullPointerException(JGitText.get().expectedBooleanStringValue); @@ -230,7 +216,7 @@ public final class StringUtils { * @return the boolean interpretation of {@code value} or null in case the * string does not represent a boolean value */ - public static Boolean toBooleanOrNull(final String stringValue) { + public static Boolean toBooleanOrNull(String stringValue) { if (stringValue == null) return null; @@ -291,8 +277,58 @@ public final class StringUtils { return sb.toString(); } - private StringUtils() { - // Do not create instances + /** + * Remove the specified character from beginning and end of a string + * <p> + * If the character repeats, all copies + * + * @param str input string + * @param c character to remove + * @return the input string with c + * @since 7.2 + */ + public static String trim(String str, char c) { + if (str == null || str.length() == 0) { + return str; + } + + int endPos = str.length()-1; + while (endPos >= 0 && str.charAt(endPos) == c) { + endPos--; + } + + // Whole string is c + if (endPos == -1) { + return EMPTY; + } + + int startPos = 0; + while (startPos < endPos && str.charAt(startPos) == c) { + startPos++; + } + + if (startPos == 0 && endPos == str.length()-1) { + // No need to copy + return str; + } + + return str.substring(startPos, endPos+1); + } + + /** + * Appends {@link Constants#DOT_GIT_EXT} unless the given name already ends + * with that suffix. + * + * @param name + * to complete + * @return the name ending with {@link Constants#DOT_GIT_EXT} + * @since 6.1 + */ + public static String nameWithDotGit(String name) { + if (name.endsWith(Constants.DOT_GIT_EXT)) { + return name; + } + return name + Constants.DOT_GIT_EXT; } /** @@ -319,17 +355,188 @@ public final class StringUtils { int o = 0; for (int i = 0; i < buf.length; ++i) { char ch = in.charAt(i); - if (ch == '\r') { + switch (ch) { + case '\r': if (i + 1 < buf.length && in.charAt(i + 1) == '\n') { buf[o++] = ' '; ++i; } else buf[o++] = ' '; - } else if (ch == '\n') + break; + case '\n': buf[o++] = ' '; - else + break; + default: buf[o++] = ch; + break; + } } return new String(buf, 0, o); } + + /** + * Parses a number with optional case-insensitive suffix 'k', 'm', or 'g' + * indicating KiB, MiB, and GiB, respectively. The suffix may follow the + * number with optional separation by one or more blanks. + * + * @param value + * {@link String} to parse; with leading and trailing whitespace + * ignored + * @param positiveOnly + * {@code true} to only accept positive numbers, {@code false} to + * allow negative numbers, too + * @return the value parsed + * @throws NumberFormatException + * if the {@code value} is not parseable, or beyond the range of + * {@link Long} + * @throws StringIndexOutOfBoundsException + * if the string is empty or contains only whitespace, or + * contains only the letter 'k', 'm', or 'g' + * @since 6.0 + */ + public static long parseLongWithSuffix(@NonNull String value, + boolean positiveOnly) + throws NumberFormatException, StringIndexOutOfBoundsException { + String n = value.strip(); + if (n.isEmpty()) { + throw new StringIndexOutOfBoundsException(); + } + long mul = 1; + switch (n.charAt(n.length() - 1)) { + case 'g': + case 'G': + mul = GiB; + break; + case 'm': + case 'M': + mul = MiB; + break; + case 'k': + case 'K': + mul = KiB; + break; + default: + break; + } + if (mul > 1) { + n = n.substring(0, n.length() - 1).trim(); + } + if (n.isEmpty()) { + throw new StringIndexOutOfBoundsException(); + } + long number; + if (positiveOnly) { + number = Long.parseUnsignedLong(n); + if (number < 0) { + throw new NumberFormatException( + MessageFormat.format(JGitText.get().valueExceedsRange, + value, Long.class.getSimpleName())); + } + } else { + number = Long.parseLong(n); + } + if (mul == 1) { + return number; + } + try { + return Math.multiplyExact(mul, number); + } catch (ArithmeticException e) { + NumberFormatException nfe = new NumberFormatException( + e.getLocalizedMessage()); + nfe.initCause(e); + throw nfe; + } + } + + /** + * Parses a number with optional case-insensitive suffix 'k', 'm', or 'g' + * indicating KiB, MiB, and GiB, respectively. The suffix may follow the + * number with optional separation by blanks. + * + * @param value + * {@link String} to parse; with leading and trailing whitespace + * ignored + * @param positiveOnly + * {@code true} to only accept positive numbers, {@code false} to + * allow negative numbers, too + * @return the value parsed + * @throws NumberFormatException + * if the {@code value} is not parseable or beyond the range of + * {@link Integer} + * @throws StringIndexOutOfBoundsException + * if the string is empty or contains only whitespace, or + * contains only the letter 'k', 'm', or 'g' + * @since 6.0 + */ + public static int parseIntWithSuffix(@NonNull String value, + boolean positiveOnly) + throws NumberFormatException, StringIndexOutOfBoundsException { + try { + return Math.toIntExact(parseLongWithSuffix(value, positiveOnly)); + } catch (ArithmeticException e) { + NumberFormatException nfe = new NumberFormatException( + MessageFormat.format(JGitText.get().valueExceedsRange, + value, Integer.class.getSimpleName())); + nfe.initCause(e); + throw nfe; + } + } + + /** + * Formats an integral value as a decimal number with 'k', 'm', or 'g' + * suffix if it is an exact multiple of 1024, otherwise returns the value + * representation as a decimal number without suffix. + * + * @param value + * Value to format + * @return the value's String representation + * @since 6.0 + */ + public static String formatWithSuffix(long value) { + if (value >= GiB && (value % GiB) == 0) { + return String.valueOf(value / GiB) + 'g'; + } + if (value >= MiB && (value % MiB) == 0) { + return String.valueOf(value / MiB) + 'm'; + } + if (value >= KiB && (value % KiB) == 0) { + return String.valueOf(value / KiB) + 'k'; + } + return String.valueOf(value); + } + + /** + * Compares Strings and returns the initial sequence of characters that is + * common to all of them. + * + * @param strings + * Strings to consider + * @return common prefix of all Strings + * @since 6.8 + */ + public static @NonNull String commonPrefix(@Nullable String... strings) { + if (strings == null || strings.length == 0) { + return EMPTY; + } + String first = strings[0]; + if (first == null) { + return EMPTY; + } + if (strings.length == 1) { + return first; + } + for (int i = 0; i < first.length(); i++) { + char currentChar = first.charAt(i); + for (int j = 1; j < strings.length; j++) { + String str = strings[j]; + if (str == null) { + return EMPTY; + } + if (str.length() == i || currentChar != str.charAt(i)) { + return str.substring(0, i); + } + } + } + return first; + } } |