1/*
2 * Copyright (C) 2010 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.google.common.base;
18
19import static com.google.common.base.Preconditions.checkArgument;
20import static com.google.common.base.Preconditions.checkNotNull;
21
22import com.google.common.annotations.Beta;
23import com.google.common.annotations.GwtCompatible;
24import com.google.common.annotations.VisibleForTesting;
25
26import java.util.Formatter;
27
28import javax.annotation.Nullable;
29
30/**
31 * Static utility methods pertaining to {@code String} or {@code CharSequence}
32 * instances.
33 *
34 * @author Kevin Bourrillion
35 * @since 3.0
36 */
37@GwtCompatible
38public final class Strings {
39  private Strings() {}
40
41  /**
42   * Returns the given string if it is non-null; the empty string otherwise.
43   *
44   * @param string the string to test and possibly return
45   * @return {@code string} itself if it is non-null; {@code ""} if it is null
46   */
47  public static String nullToEmpty(@Nullable String string) {
48    return (string == null) ? "" : string;
49  }
50
51  /**
52   * Returns the given string if it is nonempty; {@code null} otherwise.
53   *
54   * @param string the string to test and possibly return
55   * @return {@code string} itself if it is nonempty; {@code null} if it is
56   *     empty or null
57   */
58  public static @Nullable String emptyToNull(@Nullable String string) {
59    return isNullOrEmpty(string) ? null : string;
60  }
61
62  /**
63   * Returns {@code true} if the given string is null or is the empty string.
64   *
65   * <p>Consider normalizing your string references with {@link #nullToEmpty}.
66   * If you do, you can use {@link String#isEmpty()} instead of this
67   * method, and you won't need special null-safe forms of methods like {@link
68   * String#toUpperCase} either. Or, if you'd like to normalize "in the other
69   * direction," converting empty strings to {@code null}, you can use {@link
70   * #emptyToNull}.
71   *
72   * @param string a string reference to check
73   * @return {@code true} if the string is null or is the empty string
74   */
75  public static boolean isNullOrEmpty(@Nullable String string) {
76    return string == null || string.length() == 0; // string.isEmpty() in Java 6
77  }
78
79  /**
80   * Returns a string, of length at least {@code minLength}, consisting of
81   * {@code string} prepended with as many copies of {@code padChar} as are
82   * necessary to reach that length. For example,
83   *
84   * <ul>
85   * <li>{@code padStart("7", 3, '0')} returns {@code "007"}
86   * <li>{@code padStart("2010", 3, '0')} returns {@code "2010"}
87   * </ul>
88   *
89   * <p>See {@link Formatter} for a richer set of formatting capabilities.
90   *
91   * @param string the string which should appear at the end of the result
92   * @param minLength the minimum length the resulting string must have. Can be
93   *     zero or negative, in which case the input string is always returned.
94   * @param padChar the character to insert at the beginning of the result until
95   *     the minimum length is reached
96   * @return the padded string
97   */
98  public static String padStart(String string, int minLength, char padChar) {
99    checkNotNull(string);  // eager for GWT.
100    if (string.length() >= minLength) {
101      return string;
102    }
103    StringBuilder sb = new StringBuilder(minLength);
104    for (int i = string.length(); i < minLength; i++) {
105      sb.append(padChar);
106    }
107    sb.append(string);
108    return sb.toString();
109  }
110
111  /**
112   * Returns a string, of length at least {@code minLength}, consisting of
113   * {@code string} appended with as many copies of {@code padChar} as are
114   * necessary to reach that length. For example,
115   *
116   * <ul>
117   * <li>{@code padEnd("4.", 5, '0')} returns {@code "4.000"}
118   * <li>{@code padEnd("2010", 3, '!')} returns {@code "2010"}
119   * </ul>
120   *
121   * <p>See {@link Formatter} for a richer set of formatting capabilities.
122   *
123   * @param string the string which should appear at the beginning of the result
124   * @param minLength the minimum length the resulting string must have. Can be
125   *     zero or negative, in which case the input string is always returned.
126   * @param padChar the character to append to the end of the result until the
127   *     minimum length is reached
128   * @return the padded string
129   */
130  public static String padEnd(String string, int minLength, char padChar) {
131    checkNotNull(string);  // eager for GWT.
132    if (string.length() >= minLength) {
133      return string;
134    }
135    StringBuilder sb = new StringBuilder(minLength);
136    sb.append(string);
137    for (int i = string.length(); i < minLength; i++) {
138      sb.append(padChar);
139    }
140    return sb.toString();
141  }
142
143  /**
144   * Returns a string consisting of a specific number of concatenated copies of
145   * an input string. For example, {@code repeat("hey", 3)} returns the string
146   * {@code "heyheyhey"}.
147   *
148   * @param string any non-null string
149   * @param count the number of times to repeat it; a nonnegative integer
150   * @return a string containing {@code string} repeated {@code count} times
151   *     (the empty string if {@code count} is zero)
152   * @throws IllegalArgumentException if {@code count} is negative
153   */
154  public static String repeat(String string, int count) {
155    checkNotNull(string);  // eager for GWT.
156
157    if (count <= 1) {
158      checkArgument(count >= 0, "invalid count: %s", count);
159      return (count == 0) ? "" : string;
160    }
161
162    // IF YOU MODIFY THE CODE HERE, you must update StringsRepeatBenchmark
163    final int len = string.length();
164    final long longSize = (long) len * (long) count;
165    final int size = (int) longSize;
166    if (size != longSize) {
167      throw new ArrayIndexOutOfBoundsException("Required array size too large: "
168          + String.valueOf(longSize));
169    }
170
171    final char[] array = new char[size];
172    string.getChars(0, len, array, 0);
173    int n;
174    for (n = len; n < size - n; n <<= 1) {
175      System.arraycopy(array, 0, array, n, n);
176    }
177    System.arraycopy(array, 0, array, n, size - n);
178    return new String(array);
179  }
180
181  /**
182   * Returns the longest string {@code prefix} such that
183   * {@code a.toString().startsWith(prefix) && b.toString().startsWith(prefix)},
184   * taking care not to split surrogate pairs. If {@code a} and {@code b} have
185   * no common prefix, returns the empty string.
186   *
187   * @since 11.0
188   */
189  @Beta
190  public static String commonPrefix(CharSequence a, CharSequence b) {
191    checkNotNull(a);
192    checkNotNull(b);
193
194    int maxPrefixLength = Math.min(a.length(), b.length());
195    int p = 0;
196    while (p < maxPrefixLength && a.charAt(p) == b.charAt(p)) {
197      p++;
198    }
199    if (validSurrogatePairAt(a, p - 1) || validSurrogatePairAt(b, p - 1)) {
200      p--;
201    }
202    return a.subSequence(0, p).toString();
203  }
204
205  /**
206   * Returns the longest string {@code suffix} such that
207   * {@code a.toString().endsWith(suffix) && b.toString().endsWith(suffix)},
208   * taking care not to split surrogate pairs. If {@code a} and {@code b} have
209   * no common suffix, returns the empty string.
210   *
211   * @since 11.0
212   */
213  @Beta
214  public static String commonSuffix(CharSequence a, CharSequence b) {
215    checkNotNull(a);
216    checkNotNull(b);
217
218    int maxSuffixLength = Math.min(a.length(), b.length());
219    int s = 0;
220    while (s < maxSuffixLength
221        && a.charAt(a.length() - s - 1) == b.charAt(b.length() - s - 1)) {
222      s++;
223    }
224    if (validSurrogatePairAt(a, a.length() - s - 1)
225        || validSurrogatePairAt(b, b.length() - s - 1)) {
226      s--;
227    }
228    return a.subSequence(a.length() - s, a.length()).toString();
229  }
230
231  /**
232   * True when a valid surrogate pair starts at the given {@code index} in the
233   * given {@code string}. Out-of-range indexes return false.
234   */
235  @VisibleForTesting
236  static boolean validSurrogatePairAt(CharSequence string, int index) {
237    return index >= 0 && index <= (string.length() - 2)
238        && Character.isHighSurrogate(string.charAt(index))
239        && Character.isLowSurrogate(string.charAt(index + 1));
240  }
241}
242