1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache license, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the license for the specific language governing permissions and
15 * limitations under the license.
16 */
17 package org.apache.logging.log4j.util;
18
19 import java.util.Iterator;
20 import java.util.Locale;
21 import java.util.Objects;
22
23 /**
24 * <em>Consider this class private.</em>
25 *
26 * @see <a href="http://commons.apache.org/proper/commons-lang/">Apache Commons Lang</a>
27 */
28 public final class Strings {
29
30 /**
31 * The empty string.
32 */
33 public static final String EMPTY = "";
34
35 /**
36 * OS-dependent line separator, defaults to {@code "\n"} if the system property {@code ""line.separator"} cannot be
37 * read.
38 */
39 public static final String LINE_SEPARATOR = PropertiesUtil.getProperties().getStringProperty("line.separator",
40 "\n");
41
42 private Strings() {
43 // empty
44 }
45
46 /**
47 * Returns a double quoted string.
48 *
49 * @param str a String
50 * @return {@code "str"}
51 */
52 public static String dquote(final String str) {
53 return Chars.DQUOTE + str + Chars.DQUOTE;
54 }
55
56 /**
57 * Checks if a String is blank. A blank string is one that is {@code null}, empty, or when trimmed using
58 * {@link String#trim()} is empty.
59 *
60 * @param s the String to check, may be {@code null}
61 * @return {@code true} if the String is {@code null}, empty, or trims to empty.
62 */
63 public static boolean isBlank(final String s) {
64 return s == null || s.trim().isEmpty();
65 }
66
67 /**
68 * <p>
69 * Checks if a CharSequence is empty ("") or null.
70 * </p>
71 *
72 * <pre>
73 * Strings.isEmpty(null) = true
74 * Strings.isEmpty("") = true
75 * Strings.isEmpty(" ") = false
76 * Strings.isEmpty("bob") = false
77 * Strings.isEmpty(" bob ") = false
78 * </pre>
79 *
80 * <p>
81 * NOTE: This method changed in Lang version 2.0. It no longer trims the CharSequence. That functionality is
82 * available in isBlank().
83 * </p>
84 *
85 * <p>
86 * Copied from Apache Commons Lang org.apache.commons.lang3.StringUtils.isEmpty(CharSequence)
87 * </p>
88 *
89 * @param cs the CharSequence to check, may be null
90 * @return {@code true} if the CharSequence is empty or null
91 */
92 public static boolean isEmpty(final CharSequence cs) {
93 return cs == null || cs.length() == 0;
94 }
95
96 /**
97 * Checks if a String is not blank. The opposite of {@link #isBlank(String)}.
98 *
99 * @param s the String to check, may be {@code null}
100 * @return {@code true} if the String is non-{@code null} and has content after being trimmed.
101 */
102 public static boolean isNotBlank(final String s) {
103 return !isBlank(s);
104 }
105
106 /**
107 * <p>
108 * Checks if a CharSequence is not empty ("") and not null.
109 * </p>
110 *
111 * <pre>
112 * Strings.isNotEmpty(null) = false
113 * Strings.isNotEmpty("") = false
114 * Strings.isNotEmpty(" ") = true
115 * Strings.isNotEmpty("bob") = true
116 * Strings.isNotEmpty(" bob ") = true
117 * </pre>
118 *
119 * <p>
120 * Copied from Apache Commons Lang org.apache.commons.lang3.StringUtils.isNotEmpty(CharSequence)
121 * </p>
122 *
123 * @param cs the CharSequence to check, may be null
124 * @return {@code true} if the CharSequence is not empty and not null
125 */
126 public static boolean isNotEmpty(final CharSequence cs) {
127 return !isEmpty(cs);
128 }
129
130 /**
131 * Returns a quoted string.
132 *
133 * @param str a String
134 * @return {@code 'str'}
135 */
136 public static String quote(final String str) {
137 return Chars.QUOTE + str + Chars.QUOTE;
138 }
139
140 /**
141 * Shorthand for {@code str.toUpperCase(Locale.ROOT);}
142 * @param str The string to upper case.
143 * @return a new string
144 * @see String#toLowerCase(Locale)
145 */
146 public String toRootUpperCase(final String str) {
147 return str.toUpperCase(Locale.ROOT);
148 }
149
150 /**
151 * <p>
152 * Removes control characters (char <= 32) from both ends of this String returning {@code null} if the String is
153 * empty ("") after the trim or if it is {@code null}.
154 *
155 * <p>
156 * The String is trimmed using {@link String#trim()}. Trim removes start and end characters <= 32.
157 * </p>
158 *
159 * <pre>
160 * Strings.trimToNull(null) = null
161 * Strings.trimToNull("") = null
162 * Strings.trimToNull(" ") = null
163 * Strings.trimToNull("abc") = "abc"
164 * Strings.trimToNull(" abc ") = "abc"
165 * </pre>
166 *
167 * <p>
168 * Copied from Apache Commons Lang org.apache.commons.lang3.StringUtils.trimToNull(String)
169 * </p>
170 *
171 * @param str the String to be trimmed, may be null
172 * @return the trimmed String, {@code null} if only chars <= 32, empty or null String input
173 */
174 public static String trimToNull(final String str) {
175 final String ts = str == null ? null : str.trim();
176 return isEmpty(ts) ? null : ts;
177 }
178
179 /**
180 * <p>Joins the elements of the provided {@code Iterable} into
181 * a single String containing the provided elements.</p>
182 *
183 * <p>No delimiter is added before or after the list. Null objects or empty
184 * strings within the iteration are represented by empty strings.</p>
185 *
186 * @param iterable the {@code Iterable} providing the values to join together, may be null
187 * @param separator the separator character to use
188 * @return the joined String, {@code null} if null iterator input
189 */
190 public static String join(final Iterable<?> iterable, final char separator) {
191 if (iterable == null) {
192 return null;
193 }
194 return join(iterable.iterator(), separator);
195 }
196
197 /**
198 * <p>Joins the elements of the provided {@code Iterator} into
199 * a single String containing the provided elements.</p>
200 *
201 * <p>No delimiter is added before or after the list. Null objects or empty
202 * strings within the iteration are represented by empty strings.</p>
203 *
204 * @param iterator the {@code Iterator} of values to join together, may be null
205 * @param separator the separator character to use
206 * @return the joined String, {@code null} if null iterator input
207 */
208 public static String join(final Iterator<?> iterator, final char separator) {
209
210 // handle null, zero and one elements before building a buffer
211 if (iterator == null) {
212 return null;
213 }
214 if (!iterator.hasNext()) {
215 return EMPTY;
216 }
217 final Object first = iterator.next();
218 if (!iterator.hasNext()) {
219 return Objects.toString(first);
220 }
221
222 // two or more elements
223 final StringBuilder buf = new StringBuilder(256); // Java default is 16, probably too small
224 if (first != null) {
225 buf.append(first);
226 }
227
228 while (iterator.hasNext()) {
229 buf.append(separator);
230 final Object obj = iterator.next();
231 if (obj != null) {
232 buf.append(obj);
233 }
234 }
235
236 return buf.toString();
237 }
238
239 }