001    /*
002     * Copyright (C) 2010 The Guava Authors
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     * http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    
017    package com.google.common.base;
018    
019    import static com.google.common.base.Preconditions.checkArgument;
020    import static com.google.common.base.Preconditions.checkNotNull;
021    
022    import com.google.common.annotations.GwtCompatible;
023    import com.google.common.annotations.VisibleForTesting;
024    
025    import java.util.Formatter;
026    
027    import javax.annotation.Nullable;
028    
029    /**
030     * Static utility methods pertaining to {@code String} or {@code CharSequence}
031     * instances.
032     *
033     * @author Kevin Bourrillion
034     * @since 3.0
035     */
036    @GwtCompatible
037    public final class Strings {
038      private Strings() {}
039    
040      /**
041       * Returns the given string if it is non-null; the empty string otherwise.
042       *
043       * @param string the string to test and possibly return
044       * @return {@code string} itself if it is non-null; {@code ""} if it is null
045       */
046      public static String nullToEmpty(@Nullable String string) {
047        return (string == null) ? "" : string;
048      }
049    
050      /**
051       * Returns the given string if it is nonempty; {@code null} otherwise.
052       *
053       * @param string the string to test and possibly return
054       * @return {@code string} itself if it is nonempty; {@code null} if it is
055       *     empty or null
056       */
057      public static @Nullable String emptyToNull(@Nullable String string) {
058        return isNullOrEmpty(string) ? null : string;
059      }
060    
061      /**
062       * Returns {@code true} if the given string is null or is the empty string.
063       *
064       * <p>Consider normalizing your string references with {@link #nullToEmpty}.
065       * If you do, you can use {@link String#isEmpty()} instead of this
066       * method, and you won't need special null-safe forms of methods like {@link
067       * String#toUpperCase} either. Or, if you'd like to normalize "in the other
068       * direction," converting empty strings to {@code null}, you can use {@link
069       * #emptyToNull}.
070       *
071       * @param string a string reference to check
072       * @return {@code true} if the string is null or is the empty string
073       */
074      public static boolean isNullOrEmpty(@Nullable String string) {
075        return string == null || string.length() == 0; // string.isEmpty() in Java 6
076      }
077    
078      /**
079       * Returns a string, of length at least {@code minLength}, consisting of
080       * {@code string} prepended with as many copies of {@code padChar} as are
081       * necessary to reach that length. For example,
082       *
083       * <ul>
084       * <li>{@code padStart("7", 3, '0')} returns {@code "007"}
085       * <li>{@code padStart("2010", 3, '0')} returns {@code "2010"}
086       * </ul>
087       *
088       * <p>See {@link Formatter} for a richer set of formatting capabilities.
089       *
090       * @param string the string which should appear at the end of the result
091       * @param minLength the minimum length the resulting string must have. Can be
092       *     zero or negative, in which case the input string is always returned.
093       * @param padChar the character to insert at the beginning of the result until
094       *     the minimum length is reached
095       * @return the padded string
096       */
097      public static String padStart(String string, int minLength, char padChar) {
098        checkNotNull(string);  // eager for GWT.
099        if (string.length() >= minLength) {
100          return string;
101        }
102        StringBuilder sb = new StringBuilder(minLength);
103        for (int i = string.length(); i < minLength; i++) {
104          sb.append(padChar);
105        }
106        sb.append(string);
107        return sb.toString();
108      }
109    
110      /**
111       * Returns a string, of length at least {@code minLength}, consisting of
112       * {@code string} appended with as many copies of {@code padChar} as are
113       * necessary to reach that length. For example,
114       *
115       * <ul>
116       * <li>{@code padEnd("4.", 5, '0')} returns {@code "4.000"}
117       * <li>{@code padEnd("2010", 3, '!')} returns {@code "2010"}
118       * </ul>
119       *
120       * <p>See {@link Formatter} for a richer set of formatting capabilities.
121       *
122       * @param string the string which should appear at the beginning of the result
123       * @param minLength the minimum length the resulting string must have. Can be
124       *     zero or negative, in which case the input string is always returned.
125       * @param padChar the character to append to the end of the result until the
126       *     minimum length is reached
127       * @return the padded string
128       */
129      public static String padEnd(String string, int minLength, char padChar) {
130        checkNotNull(string);  // eager for GWT.
131        if (string.length() >= minLength) {
132          return string;
133        }
134        StringBuilder sb = new StringBuilder(minLength);
135        sb.append(string);
136        for (int i = string.length(); i < minLength; i++) {
137          sb.append(padChar);
138        }
139        return sb.toString();
140      }
141    
142      /**
143       * Returns a string consisting of a specific number of concatenated copies of
144       * an input string. For example, {@code repeat("hey", 3)} returns the string
145       * {@code "heyheyhey"}.
146       *
147       * @param string any non-null string
148       * @param count the number of times to repeat it; a nonnegative integer
149       * @return a string containing {@code string} repeated {@code count} times
150       *     (the empty string if {@code count} is zero)
151       * @throws IllegalArgumentException if {@code count} is negative
152       */
153      public static String repeat(String string, int count) {
154        checkNotNull(string);  // eager for GWT.
155    
156        if (count <= 1) {
157          checkArgument(count >= 0, "invalid count: %s", count);
158          return (count == 0) ? "" : string;
159        }
160    
161        // IF YOU MODIFY THE CODE HERE, you must update StringsRepeatBenchmark
162        final int len = string.length();
163        final long longSize = (long) len * (long) count;
164        final int size = (int) longSize;
165        if (size != longSize) {
166          throw new ArrayIndexOutOfBoundsException("Required array size too large: "
167              + String.valueOf(longSize));
168        }
169    
170        final char[] array = new char[size];
171        string.getChars(0, len, array, 0);
172        int n;
173        for (n = len; n < size - n; n <<= 1) {
174          System.arraycopy(array, 0, array, n, n);
175        }
176        System.arraycopy(array, 0, array, n, size - n);
177        return new String(array);
178      }
179    
180      /**
181       * Returns the longest string {@code prefix} such that
182       * {@code a.toString().startsWith(prefix) && b.toString().startsWith(prefix)},
183       * taking care not to split surrogate pairs. If {@code a} and {@code b} have
184       * no common prefix, returns the empty string.
185       *
186       * @since 11.0
187       */
188      public static String commonPrefix(CharSequence a, CharSequence b) {
189        checkNotNull(a);
190        checkNotNull(b);
191    
192        int maxPrefixLength = Math.min(a.length(), b.length());
193        int p = 0;
194        while (p < maxPrefixLength && a.charAt(p) == b.charAt(p)) {
195          p++;
196        }
197        if (validSurrogatePairAt(a, p - 1) || validSurrogatePairAt(b, p - 1)) {
198          p--;
199        }
200        return a.subSequence(0, p).toString();
201      }
202    
203      /**
204       * Returns the longest string {@code suffix} such that
205       * {@code a.toString().endsWith(suffix) && b.toString().endsWith(suffix)},
206       * taking care not to split surrogate pairs. If {@code a} and {@code b} have
207       * no common suffix, returns the empty string.
208       *
209       * @since 11.0
210       */
211      public static String commonSuffix(CharSequence a, CharSequence b) {
212        checkNotNull(a);
213        checkNotNull(b);
214    
215        int maxSuffixLength = Math.min(a.length(), b.length());
216        int s = 0;
217        while (s < maxSuffixLength
218            && a.charAt(a.length() - s - 1) == b.charAt(b.length() - s - 1)) {
219          s++;
220        }
221        if (validSurrogatePairAt(a, a.length() - s - 1)
222            || validSurrogatePairAt(b, b.length() - s - 1)) {
223          s--;
224        }
225        return a.subSequence(a.length() - s, a.length()).toString();
226      }
227    
228      /**
229       * True when a valid surrogate pair starts at the given {@code index} in the
230       * given {@code string}. Out-of-range indexes return false.
231       */
232      @VisibleForTesting
233      static boolean validSurrogatePairAt(CharSequence string, int index) {
234        return index >= 0 && index <= (string.length() - 2)
235            && Character.isHighSurrogate(string.charAt(index))
236            && Character.isLowSurrogate(string.charAt(index + 1));
237      }
238    }