import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
private static void _performConsistencyChecks (@Nonnull final String sValue)
{
  // String contains masked newline? warning only!
  if (sValue.contains ("\\n"))
    s_aLogger.warn ("Passed string contains a masked newline - replace with an inline one:\n" + sValue);

  if (sValue.contains ("{0}"))
  {
    // When formatting is used, 2 single quotes are required!
    if (RegExHelper.stringMatchesPattern ("^'[^'].*", sValue))
      throw new IllegalArgumentException ("The passed string seems to start with unclosed single quotes: " + sValue);
    if (RegExHelper.stringMatchesPattern (".*[^']'[^'].*", sValue))
      throw new IllegalArgumentException ("The passed string seems to contain unclosed single quotes: " + sValue);
  }
  else
  {
    // When no formatting is used, single quotes are required!
    if (RegExHelper.stringMatchesPattern (".*''.*", sValue))
      throw new IllegalArgumentException ("The passed string seems to contain 2 single quotes: " + sValue);
  }
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
/**
 * Create a file filter that matches, if it matches one of the provided
 * regular expressions
 *
 * @param aRegExs
 *        The regular expressions to match against. May neither be
 *        <code>null</code> nor empty.
 * @return The created {@link IFileFilter}. Never <code>null</code>.
 * @see #filenameMatchNoRegEx(String...)
 * @see #filenameMatchAny(String...)
 * @see #filenameMatchNone(String...)
 */
@Nonnull
static IFileFilter filenameMatchAnyRegEx (@Nonnull @Nonempty final String... aRegExs)
{
  ValueEnforcer.notEmpty (aRegExs, "RegularExpressions");
  return aFile -> {
    if (aFile != null)
    {
      final String sRealName = FilenameHelper.getSecureFilename (aFile.getName ());
      if (sRealName != null)
        for (final String sRegEx : aRegExs)
          if (RegExHelper.stringMatchesPattern (sRegEx, sRealName))
            return true;
    }
    return false;
  };
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
/**
 * Create a file filter that matches, if it matches none of the provided
 * regular expressions
 *
 * @param aRegExs
 *        The regular expressions to match against. May neither be
 *        <code>null</code> nor empty.
 * @return The created {@link IFileFilter}. Never <code>null</code>.
 * @see #filenameMatchAnyRegEx(String...)
 * @see #filenameMatchAny(String...)
 * @see #filenameMatchNone(String...)
 */
@Nonnull
static IFileFilter filenameMatchNoRegEx (@Nonnull @Nonempty final String... aRegExs)
{
  ValueEnforcer.notEmpty (aRegExs, "RegularExpressions");
  return aFile -> {
    if (aFile == null)
      return false;
    final String sRealName = FilenameHelper.getSecureFilename (aFile.getName ());
    if (sRealName == null)
      return false;
    for (final String sRegEx : aRegExs)
      if (RegExHelper.stringMatchesPattern (sRegEx, sRealName))
        return false;
    return true;
  };
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
/**
 * Make an IBAN that can be parsed. It is converted to upper case and all
 * non-alphanumeric characters are removed.
 *
 * @param sIBAN
 *        The IBAN to be unified.
 * @return The unified string or <code>null</code> if this is no IBAN at all.
 */
@Nullable
public static String unifyIBAN (@Nullable final String sIBAN)
{
  if (sIBAN == null)
    return null;

  // to uppercase
  String sRealIBAN = sIBAN.toUpperCase (Locale.US);

  // kick all non-IBAN chars
  sRealIBAN = RegExHelper.stringReplacePattern ("[^0-9A-Z]", sRealIBAN, "");
  if (sRealIBAN.length () < 4)
    return null;

  return sRealIBAN;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
public static boolean isValidISBN10Number (@Nullable final String sValue)
{
  if (sValue == null || sValue.length () != 10)
    return false;

  // Value needs to be fully numeric with a trailing 'X'
  if (!RegExHelper.stringMatchesPattern ("^[0-9]+[0-9X]?$", sValue))
    return false;

  // calc checksum
  int nRes = 0;
  for (int i = 0; i < 9; i++)
  {
    final int j = Character.digit (sValue.charAt (i), 10);
    nRes += ((j * (10 - i)) % 11);
  }
  nRes = 11 - (nRes % 11);
  final char cChkSum = (nRes == 10 ? 'X' : Character.forDigit (nRes, 10));
  return cChkSum == sValue.charAt (9);
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
public static boolean isValidISBN13Number (@Nullable final String sValue)
{
  if (sValue == null || sValue.length () != 13)
    return false;
  // Value needs to be fully numeric
  if (!RegExHelper.stringMatchesPattern ("^[0-9]+$", sValue))
    return false;

  // calc checksum
  int nRes = 0;
  for (int i = 0; i < 12; i++)
  {
    final int j = Character.digit (sValue.charAt (i), 10);
    final int k = 1 + ((i % 2) * 2);
    nRes += ((j * k) % 10);
  }
  nRes = (10 - (nRes % 10)) % 10;
  return Character.forDigit (nRes, 10) == sValue.charAt (12);
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
/**
 * Convert an "unsexy" location string in the for, of
 * <code>*:xx[namespace-uri()='yy']</code> to something more readable like
 * <code>prefix:xx</code> by using the mapping registered in the
 * {@link SVRLLocationBeautifierRegistry}.
 *
 * @param sLocation
 *        The original location string. May not be <code>null</code>.
 * @return The beautified string. Never <code>null</code>. Might be identical
 *         to the original string if the pattern was not found.
 * @since 5.0.1
 */
@Nonnull
public static String getBeautifiedLocation (@Nonnull final String sLocation)
{
  String sResult = sLocation;
  // Handle namespaces:
  // Search for "*:xx[namespace-uri()='yy']" where xx is the localname and yy
  // is the namespace URI
  final Matcher aMatcher = RegExHelper.getMatcher ("\\Q*:\\E([a-zA-Z0-9_]+)\\Q[namespace-uri()='\\E([^']+)\\Q']\\E",
                                                   sResult);
  while (aMatcher.find ())
  {
    final String sLocalName = aMatcher.group (1);
    final String sNamespaceURI = aMatcher.group (2);

    // Check if there is a known beautifier for this pair of namespace and
    // local name
    final String sBeautified = SVRLLocationBeautifierRegistry.getBeautifiedLocation (sNamespaceURI, sLocalName);
    if (sBeautified != null)
      sResult = StringHelper.replaceAll (sResult, aMatcher.group (), sBeautified);
  }
  return sResult;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
@Override
@OverridingMethodsMustInvokeSuper
public boolean isValidValue (@Nullable final String sValue)
{
  if (sValue == null)
    return false;

  // Split by whitespaces " a b " results in { "a", "b" }
  final String [] aParts = RegExHelper.getSplitToArray (sValue.trim (), "\\s+");
  if (aParts.length < getMinimumArgumentCount () || aParts.length > getMaximumArgumentCount ())
    return false;

  // Check each value
  for (final String aPart : aParts)
  {
    final String sTrimmedPart = aPart.trim ();
    if (!super.isValidValue (sTrimmedPart) && !CSSColorHelper.isColorValue (sTrimmedPart))
      return false;
  }
  return true;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
@Override
@OverridingMethodsMustInvokeSuper
public boolean isValidValue (@Nullable final String sValue)
{
  if (super.isValidValue (sValue))
    return true;

  if (sValue == null)
    return false;

  // Split by whitespaces
  final String [] aParts = RegExHelper.getSplitToArray (sValue.trim (), "\\s+");
  if (aParts.length < m_nMinNumbers || aParts.length > m_nMaxNumbers)
    return false;

  // Check if each part is a valid number
  for (final String sPart : aParts)
    if (!CSSNumberHelper.isValueWithUnit (sPart.trim (), m_bWithPercentage))
      return false;
  return true;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
@Override
@OverridingMethodsMustInvokeSuper
public boolean isValidValue (@Nullable final String sValue)
{
  if (sValue == null)
    return false;

  // Split by whitespaces " a b " results in { "a", "b" }
  final String [] aParts = RegExHelper.getSplitToArray (sValue.trim (), "\\s+");
  if (aParts.length < getMinimumArgumentCount () || aParts.length > getMaximumArgumentCount ())
    return false;

  for (final String sPart : aParts)
    if (!super.isValidValue (sPart.trim ()))
      return false;
  return true;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
@Override
@OverridingMethodsMustInvokeSuper
public boolean isValidValue (@Nullable final String sValue)
{
  if (sValue == null)
    return false;

  // Split by whitespaces " a b " results in { "a", "b" }
  final String [] aParts = RegExHelper.getSplitToArray (sValue.trim (), "\\s+");
  if (aParts.length < m_nMinNumbers || aParts.length > m_nMaxNumbers)
    return false;

  for (final String aPart : aParts)
  {
    final String sTrimmedPart = aPart.trim ();
    if (!super.isValidValue (sTrimmedPart) && !CSSNumberHelper.isValueWithUnit (sTrimmedPart, m_bWithPercentage))
      return false;
  }
  return true;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
/**
 * Check if the passed value is CSS rectangle definition or not. It checks
 * both the current syntax (<code>rect(a,b,c,d)</code>) and the old syntax (
 * <code>rect(a b c d)</code>).
 *
 * @param sCSSValue
 *        The value to check. May be <code>null</code>.
 * @return <code>true</code> if the passed value is a rect value,
 *         <code>false</code> if not
 */
public static boolean isRectValue (@Nullable final String sCSSValue)
{
  final String sRealValue = StringHelper.trim (sCSSValue);
  if (StringHelper.hasText (sRealValue))
  {
    // Current syntax: rect(a,b,c,d)
    if (RegExHelper.stringMatchesPattern (PATTERN_CURRENT_SYNTAX, sRealValue))
      return true;

    // Backward compatible syntax: rect(a b c d)
    if (RegExHelper.stringMatchesPattern (PATTERN_OLD_SYNTAX, sRealValue))
      return true;
  }
  return false;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
/**
 * Split a user provided query string into the terms relevant for querying
 * using the provided Lucene Analyzer. This will e.g. remove ":" from a word
 * etc.
 *
 * @param aAnalyzerProvider
 *        Analyzer provider. E.g. instance of
 *        {@link com.helger.pd.indexer.lucene.PDLucene}.
 * @param sFieldName
 *        Lucene field name to get split into terms.
 * @param sQueryString
 *        The user provided query string. Must neither be <code>null</code>
 *        nor empty.
 * @return The non-<code>null</code> list of all terms.
 */
@Nonnull
public static ICommonsList <String> getSplitIntoTerms (@Nonnull final ILuceneAnalyzerProvider aAnalyzerProvider,
                                                       @Nonnull @Nonempty final String sFieldName,
                                                       @Nonnull @Nonempty final String sQueryString)
{
  // Use the default analyzer to split the query string into fields
  try (final TokenStream aTokenStream = aAnalyzerProvider.getAnalyzer ().tokenStream (sFieldName, sQueryString))
  {
    final ICommonsList <String> ret = new CommonsArrayList <> ();
    final CharTermAttribute aCharTermAttribute = aTokenStream.addAttribute (CharTermAttribute.class);
    aTokenStream.reset ();
    while (aTokenStream.incrementToken ())
    {
      final String sTerm = aCharTermAttribute.toString ();
      ret.add (sTerm);
    }
    aTokenStream.end ();
    return ret;
  }
  catch (final IOException ex)
  {
    s_aLogger.warn ("Failed to split user query '" + sQueryString + "' into terms. Defaulting to regEx splitting",
                    ex);
    // Fall-back
    return RegExHelper.getSplitToList (sQueryString.trim (), "\\s+");
  }
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
private static boolean _containsER (final String s, final int c)
{
  if (s.indexOf ("&#" + c + ";") >= 0)
    return true;
  if (s.indexOf ("&#x" + Integer.toString (c, 16) + ";") >= 0)
    return true;
  return RegExHelper.stringMatchesPattern (".+&[a-z]+;.+", s);
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
@Nullable
public static String getValidLanguageCode (@Nullable final String sCode)
{
  if (StringHelper.hasText (sCode) &&
      (RegExHelper.stringMatchesPattern ("[a-zA-Z]{2,8}", sCode) || isSpecialLocaleCode (sCode)))
  {
    return sCode.toLowerCase (CGlobal.LOCALE_FIXED_NUMBER_FORMAT);
  }
  return null;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
@Nullable
public static String getValidCountryCode (@Nullable final String sCode)
{
  if (StringHelper.hasText (sCode) && RegExHelper.stringMatchesPattern ("[a-zA-Z]{2}|[0-9]{3}", sCode))
  {
    return sCode.toUpperCase (CGlobal.LOCALE_FIXED_NUMBER_FORMAT);
  }
  return null;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
@Nullable
@CheckReturnValue
public static String getCleanedLine (@Nullable final String sLine)
{
  String ret = StringHelper.trim (sLine);
  if (StringHelper.hasText (ret))
  {
    // Remove the Skype highlighting :)
    ret = RegExHelper.stringReplacePattern ("begin_of_the_skype_highlighting.+end_of_the_skype_highlighting",
                                            ret,
                                            "");
  }
  return ret;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
/**
 * Set the diagnostics, as an IDREFS value (multiple IDREF values separated by
 * spaces)
 *
 * @param sDiagnostics
 *        The value to be set. May be <code>null</code>.
 */
public void setDiagnostics (@Nullable final String sDiagnostics)
{
  if (StringHelper.hasText (sDiagnostics))
    setDiagnostics (RegExHelper.getSplitToList (sDiagnostics.trim (), "\\s+"));
  else
    m_aDiagnostics = null;
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
@Nonnull
public static String splitNumber (@Nonnull final StringBuilder aPattern)
{
  // Find the longest matching number within the pattern
  final Matcher m = RegExHelper.getMatcher (SPLIT_NUMBER_REGEX, aPattern.toString ());
  if (m.matches ())
    return m.group (1);
  return "";
}
 

import com.helger.commons.regex.RegExHelper; //导入依赖的package包/类
/**
 * Get all the values from within a CSS rectangle definition.
 *
 * @param sCSSValue
 *        The CSS values to check. May be <code>null</code>.
 * @return <code>null</code> if the passed String is not a CSS rectangle. An
 *         array with 4 Strings if the passed value is a CSS rectangle.
 */
@Nullable
public static String [] getRectValues (@Nullable final String sCSSValue)
{
  String [] ret = null;
  final String sRealValue = StringHelper.trim (sCSSValue);
  if (StringHelper.hasText (sRealValue))
  {
    ret = RegExHelper.getAllMatchingGroupValues (PATTERN_CURRENT_SYNTAX, sRealValue);
    if (ret == null)
      ret = RegExHelper.getAllMatchingGroupValues (PATTERN_OLD_SYNTAX, sRealValue);
  }
  return ret;
}