content: package com.alibaba.excel.util;
  
  /**
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * @author Apache Software Foundation (ASF)
   */
  public class StringUtils {
      private StringUtils() {}
  
      /**
       * A String for a space character.
       */
      public static final String SPACE = " ";
  
      /**
       * The empty String {@code ""}.
       */
      public static final String EMPTY = "";
  
      /**
       * <p>Checks if a CharSequence is empty ("") or null.</p>
       *
       * <pre>
       * StringUtils.isEmpty(null)      = true
       * StringUtils.isEmpty("")        = true
       * StringUtils.isEmpty(" ")       = false
       * StringUtils.isEmpty("bob")     = false
       * StringUtils.isEmpty("  bob  ") = false
       * </pre>
       *
       * <p>NOTE: This method changed in Lang version 2.0.
       * It no longer trims the CharSequence.
       * That functionality is available in isBlank().</p>
       *
       * @param cs the CharSequence to check, may be null
       * @return {@code true} if the CharSequence is empty or null
       */
      public static boolean isEmpty(final CharSequence cs) {
          return cs == null || cs.length() == 0;
      }
  
      /**
       * <p>Checks if a CharSequence is empty (""), null or whitespace only.</p>
       *
       * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p>
       *
       * <pre>
       * StringUtils.isBlank(null)      = true
       * StringUtils.isBlank("")        = true
       * StringUtils.isBlank(" ")       = true
       * StringUtils.isBlank("bob")     = false
       * StringUtils.isBlank("  bob  ") = false
       * </pre>
       *
       * @param cs the CharSequence to check, may be null
       * @return {@code true} if the CharSequence is null, empty or whitespace only
       */
      public static boolean isBlank(final CharSequence cs) {
          int strLen;
          if (cs == null || (strLen = cs.length()) == 0) {
              return true;
          }
          for (int i = 0; i < strLen; i++) {
              if (!Character.isWhitespace(cs.charAt(i))) {
                  return false;
              }
          }
          return true;
      }
  
      /**
       * <p>Checks if a CharSequence is not empty (""), not null and not whitespace only.</p>
       *
       * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p>
       *
       * <pre>
       * StringUtils.isNotBlank(null)      = false
       * StringUtils.isNotBlank("")        = false
       * StringUtils.isNotBlank(" ")       = false
       * StringUtils.isNotBlank("bob")     = true
       * StringUtils.isNotBlank("  bob  ") = true
       * </pre>
       *
       * @param cs the CharSequence to check, may be null
       * @return {@code true} if the CharSequence is
       * not empty and not null and not whitespace only
       * @since 2.0
       * @since 3.0 Changed signature from isNotBlank(String) to isNotBlank(CharSequence)
       */
      public static boolean isNotBlank(final CharSequence cs) {
          return !isBlank(cs);
      }
  
      /**
       * <p>Compares two CharSequences, returning {@code true} if they represent
       * equal sequences of characters.</p>
       *
       * <p>{@code null}s are handled without exceptions. Two {@code null}
       * references are considered to be equal. The comparison is case sensitive.</p>
       *
       * <pre>
       * StringUtils.equals(null, null)   = true
       * StringUtils.equals(null, "abc")  = false
       * StringUtils.equals("abc", null)  = false
       * StringUtils.equals("abc", "abc") = true
       * StringUtils.equals("abc", "ABC") = false
       * </pre>
       *
       * @param cs1 the first CharSequence, may be {@code null}
       * @param cs2 the second CharSequence, may be {@code null}
       * @return {@code true} if the CharSequences are equal (case-sensitive), or both {@code null}
       * @see Object#equals(Object)
       * @since 3.0 Changed signature from equals(String, String) to equals(CharSequence, CharSequence)
       */
      public static boolean equals(final CharSequence cs1, final CharSequence cs2) {
          if (cs1 == cs2) {
              return true;
          }
          if (cs1 == null || cs2 == null) {
              return false;
          }
          if (cs1.length() != cs2.length()) {
              return false;
          }
          if (cs1 instanceof String && cs2 instanceof String) {
              return cs1.equals(cs2);
          }
          return regionMatches(cs1, false, 0, cs2, 0, cs1.length());
      }
  
      /**
       * Green implementation of regionMatches.
       *
       * @param cs         the {@code CharSequence} to be processed
       * @param ignoreCase whether or not to be case insensitive
       * @param thisStart  the index to start on the {@code cs} CharSequence
       * @param substring  the {@code CharSequence} to be looked for
       * @param start      the index to start on the {@code substring} CharSequence
       * @param length     character length of the region
       * @return whether the region matched
       */
      public static boolean regionMatches(final CharSequence cs, final boolean ignoreCase, final int thisStart,
          final CharSequence substring, final int start, final int length) {
          if (cs instanceof String && substring instanceof String) {
              return ((String)cs).regionMatches(ignoreCase, thisStart, (String)substring, start, length);
          }
          int index1 = thisStart;
          int index2 = start;
          int tmpLen = length;
  
          // Extract these first so we detect NPEs the same as the java.lang.String version
          final int srcLen = cs.length() - thisStart;
          final int otherLen = substring.length() - start;
  
          // Check for invalid parameters
          if (thisStart < 0 || start < 0 || length < 0) {
              return false;
          }
  
          // Check that the regions are long enough
          if (srcLen < length || otherLen < length) {
              return false;
          }
  
          while (tmpLen-- > 0) {
              final char c1 = cs.charAt(index1++);
              final char c2 = substring.charAt(index2++);
  
              if (c1 == c2) {
                  continue;
              }
  
              if (!ignoreCase) {
                  return false;
              }
  
              // The same check as in String.regionMatches():
              if (Character.toUpperCase(c1) != Character.toUpperCase(c2)
                  && Character.toLowerCase(c1) != Character.toLowerCase(c2)) {
                  return false;
              }
          }
  
          return true;
      }
  
      /**
       * <p>Checks if the CharSequence contains only Unicode digits.
       * A decimal point is not a Unicode digit and returns false.</p>
       *
       * <p>{@code null} will return {@code false}.
       * An empty CharSequence (length()=0) will return {@code false}.</p>
       *
       * <p>Note that the method does not allow for a leading sign, either positive or negative.
       * Also, if a String passes the numeric test, it may still generate a NumberFormatException
       * when parsed by Integer.parseInt or Long.parseLong, e.g. if the value is outside the range
       * for int or long respectively.</p>
       *
       * <pre>
       * StringUtils.isNumeric(null)   = false
       * StringUtils.isNumeric("")     = false
       * StringUtils.isNumeric("  ")   = false
       * StringUtils.isNumeric("123")  = true
       * StringUtils.isNumeric("\u0967\u0968\u0969")  = true
       * StringUtils.isNumeric("12 3") = false
       * StringUtils.isNumeric("ab2c") = false
       * StringUtils.isNumeric("12-3") = false
       * StringUtils.isNumeric("12.3") = false
       * StringUtils.isNumeric("-123") = false
       * StringUtils.isNumeric("+123") = false
       * </pre>
       *
       * @param cs the CharSequence to check, may be null
       * @return {@code true} if only contains digits, and is non-null
       * @since 3.0 Changed signature from isNumeric(String) to isNumeric(CharSequence)
       * @since 3.0 Changed "" to return false and not true
       */
      public static boolean isNumeric(final CharSequence cs) {
          if (isEmpty(cs)) {
              return false;
          }
          final int sz = cs.length();
          for (int i = 0; i < sz; i++) {
              if (!Character.isDigit(cs.charAt(i))) {
                  return false;
              }
          }
          return true;
      }
  }
  