001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements. See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache license, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License. You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the license for the specific language governing permissions and
015     * limitations under the license.
016     */
017    package org.apache.logging.log4j.util;
018    
019    /**
020     * <em>Consider this class private.</em>
021     * 
022     * @see <a href="http://commons.apache.org/proper/commons-lang/">Apache Commons Lang</a>
023     */
024    public final class Strings {
025    
026        /**
027         * The empty string.
028         */
029        public static final String EMPTY = "";
030    
031        private Strings() {
032        }
033    
034        /**
035         * <p>
036         * Checks if a CharSequence is empty ("") or null.
037         * </p>
038         *
039         * <pre>
040         * Strings.isEmpty(null)      = true
041         * Strings.isEmpty("")        = true
042         * Strings.isEmpty(" ")       = false
043         * Strings.isEmpty("bob")     = false
044         * Strings.isEmpty("  bob  ") = false
045         * </pre>
046         *
047         * <p>
048         * NOTE: This method changed in Lang version 2.0. It no longer trims the CharSequence. That functionality is
049         * available in isBlank().
050         * </p>
051         *
052         * <p>
053         * Copied from Apache Commons Lang org.apache.commons.lang3.StringUtils.isEmpty(CharSequence)
054         * </p>
055         *
056         * @param cs
057         *        the CharSequence to check, may be null
058         * @return {@code true} if the CharSequence is empty or null
059         */
060        public static boolean isEmpty(final CharSequence cs) {
061            return cs == null || cs.length() == 0;
062        }
063    
064        /**
065         * <p>
066         * Checks if a CharSequence is not empty ("") and not null.
067         * </p>
068         *
069         * <pre>
070         * Strings.isNotEmpty(null)      = false
071         * Strings.isNotEmpty("")        = false
072         * Strings.isNotEmpty(" ")       = true
073         * Strings.isNotEmpty("bob")     = true
074         * Strings.isNotEmpty("  bob  ") = true
075         * </pre>
076         *
077         * <p>
078         * Copied from Apache Commons Lang org.apache.commons.lang3.StringUtils.isNotEmpty(CharSequence)
079         * </p>
080         *
081         * @param cs
082         *        the CharSequence to check, may be null
083         * @return {@code true} if the CharSequence is not empty and not null
084         */
085        public static boolean isNotEmpty(final CharSequence cs) {
086            return !isEmpty(cs);
087        }
088    
089        /**
090         * Checks if a String is blank. A blank string is one that is {@code null}, empty, or when trimmed using
091         * {@link String#trim()} is empty.
092         *
093         * @param s
094         *        the String to check, may be {@code null}
095         * @return {@code true} if the String is {@code null}, empty, or trims to empty.
096         */
097        public static boolean isBlank(final String s) {
098            return s == null || s.trim().isEmpty();
099        }
100    
101        /**
102         * Checks if a String is not blank. The opposite of {@link #isBlank(String)}.
103         *
104         * @param s
105         *        the String to check, may be {@code null}
106         * @return {@code true} if the String is non-{@code null} and has content after being trimmed.
107         */
108        public static boolean isNotBlank(final String s) {
109            return !isBlank(s);
110        }
111    
112        /**
113         * <p>
114         * Removes control characters (char &lt;= 32) from both ends of this String returning {@code null} if the String is
115         * empty ("") after the trim or if it is {@code null}.
116         *
117         * <p>
118         * The String is trimmed using {@link String#trim()}. Trim removes start and end characters &lt;= 32.
119         * </p>
120         *
121         * <pre>
122         * Strings.trimToNull(null)          = null
123         * Strings.trimToNull("")            = null
124         * Strings.trimToNull("     ")       = null
125         * Strings.trimToNull("abc")         = "abc"
126         * Strings.trimToNull("    abc    ") = "abc"
127         * </pre>
128         *
129         * <p>
130         * Copied from Apache Commons Lang org.apache.commons.lang3.StringUtils.trimToNull(String)
131         * </p>
132         *
133         * @param str
134         *        the String to be trimmed, may be null
135         * @return the trimmed String, {@code null} if only chars &lt;= 32, empty or null String input
136         */
137        public static String trimToNull(final String str) {
138            final String ts = str == null ? null : str.trim();
139            return isEmpty(ts) ? null : ts;
140        }
141    
142        /**
143         * Returns a quoted string.
144         * 
145         * @param str
146         *        a String
147         * @return {@code 'str'}
148         */
149        public static String quote(final String str) {
150            return Chars.QUOTE + str + Chars.QUOTE;
151        }
152    
153        /**
154         * Returns a double quoted string.
155         * 
156         * @param str
157         *        a String
158         * @return {@code "str"}
159         */
160        public static String dquote(final String str) {
161            return Chars.DQUOTE + str + Chars.DQUOTE;
162        }
163    }