Java Pattern.DOTALL屬性代碼示例

@Override
public Pattern compile(String label)
{
    int reFlags = 0;
    if ((m_flags & SQLPatternFactory.CASE_SENSITIVE) == 0) {
        reFlags |= Pattern.CASE_INSENSITIVE;
    }
    if ((m_flags & SQLPatternFactory.IGNORE_NEW_LINE) == 0) {
        reFlags |= Pattern.DOTALL;
    }
    if ((m_flags & SQLPatternFactory.SINGLE_LINE) == 0) {
        reFlags |= Pattern.MULTILINE;
    }
    String regex = generateExpression(0);
    COMPILER_LOG.debug(String.format("PATTERN: %s: %s", label, regex));
    return Pattern.compile(regex, reFlags);
}
 

@Override
public String toString() {
    StringBuilder f = new StringBuilder();
    if ((flags & Pattern.CANON_EQ) != 0)                f.append('c');
    if ((flags & Pattern.CASE_INSENSITIVE) != 0)        f.append('i');
    if ((flags & Pattern.LITERAL) != 0)                 f.append('l');
    if ((flags & Pattern.MULTILINE) != 0)               f.append('m');
    if ((flags & Pattern.DOTALL) != 0)                  f.append('s');
    if ((flags & Pattern.UNICODE_CHARACTER_CLASS) != 0) f.append('U');
    if ((flags & Pattern.UNICODE_CASE) != 0)            f.append('u');
    if ((flags & Pattern.COMMENTS) != 0)                f.append('x');

    String p = "/" + pattern + "/";
    if (f.length() == 0) {
        return singleLineToString(p);
    }
    return singleLineToString(p, f);
}
 

public void testFlags() {
    String[] supportedFlags = new String[]{"CASE_INSENSITIVE", "MULTILINE", "DOTALL", "UNICODE_CASE", "CANON_EQ", "UNIX_LINES",
            "LITERAL", "COMMENTS", "UNICODE_CHAR_CLASS", "UNICODE_CHARACTER_CLASS"};
    int[] flags = new int[]{Pattern.CASE_INSENSITIVE, Pattern.MULTILINE, Pattern.DOTALL, Pattern.UNICODE_CASE, Pattern.CANON_EQ,
            Pattern.UNIX_LINES, Pattern.LITERAL, Pattern.COMMENTS, Regex.UNICODE_CHARACTER_CLASS};
    Random random = random();
    int num = 10 + random.nextInt(100);
    for (int i = 0; i < num; i++) {
        int numFlags = random.nextInt(flags.length + 1);
        int current = 0;
        StringBuilder builder = new StringBuilder();
        for (int j = 0; j < numFlags; j++) {
            int index = random.nextInt(flags.length);
            current |= flags[index];
            builder.append(supportedFlags[index]);
            if (j < numFlags - 1) {
                builder.append("|");
            }
        }
        String flagsToString = Regex.flagsToString(current);
        assertThat(Regex.flagsFromString(builder.toString()), equalTo(current));
        assertThat(Regex.flagsFromString(builder.toString()), equalTo(Regex.flagsFromString(flagsToString)));
        Pattern.compile("\\w\\d{1,2}", current); // accepts the flags?
    }
}
 

private int patternToJoniFlags(int flags) {
  int newFlags = 0;
  if ((flags & Pattern.CASE_INSENSITIVE) != 0) {
    newFlags |= Option.IGNORECASE;
  }
  if ((flags & Pattern.DOTALL) != 0) {
    // This does NOT mean Pattern.MULTILINE
    newFlags |= Option.MULTILINE;
  }
  if ((flags & Pattern.MULTILINE) != 0) {
    // This is what Java 8's Nashorn engine does when using joni and
    // translating Pattern's MULTILINE flag
    newFlags &= ~Option.SINGLELINE;
    newFlags |= Option.NEGATE_SINGLELINE;
  }
  return newFlags;
}
 

@Test
public void testRegexStringComparator() throws Exception {
  // test without specifying flags
  RegexStringComparator regexStringComparator = new RegexStringComparator(".+-2");
  assertTrue(regexStringComparator.areSerializedFieldsEqual(
    ProtobufUtil.toComparator(ProtobufUtil.toComparator(regexStringComparator))));

  // test with specifying flags
  try {
    new RegexStringComparator("regex", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
  } catch (Throwable t) {
    assertNull("Exception occured while created the RegexStringComparator object", t);
  }
}
 

/**
 * Constructor for Finder.
 */
public Finder(
    HTMLEditor theEditor,
    String find,
    boolean wholeWord,
    boolean matchCase,
    boolean regexp,
    String replace) {
    super();
    editor = theEditor;
    dispText = find;
    int flags = Pattern.DOTALL;
    if (!matchCase)
        flags = flags + Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE;
    _find = find;
    if (!regexp)
        _find = "\\Q" + _find + "\\E";
    if (wholeWord)
        _find = "[\\s\\p{Punct}]" + _find + "[\\s\\p{Punct}]";
    try {
        pattern = Pattern.compile(_find, flags);
    }
    catch (Exception ex) {
        ex.printStackTrace();
        pattern = null;
    }
    _replace = replace;
}
 

private int flagForChar(char c) {
    switch (c) {
        case 'c': return Pattern.CANON_EQ;
        case 'i': return Pattern.CASE_INSENSITIVE;
        case 'l': return Pattern.LITERAL;
        case 'm': return Pattern.MULTILINE;
        case 's': return Pattern.DOTALL;
        case 'U': return Pattern.UNICODE_CHARACTER_CLASS;
        case 'u': return Pattern.UNICODE_CASE;
        case 'x': return Pattern.COMMENTS;
        default:
            throw new IllegalArgumentException("Unknown flag [" + c + "]");
    }
}
 

public static int flagsFromString(String flags) {
    int pFlags = 0;
    for (String s : Strings.delimitedListToStringArray(flags, "|")) {
        if (s.isEmpty()) {
            continue;
        }
        s = s.toUpperCase(Locale.ROOT);
        if ("CASE_INSENSITIVE".equals(s)) {
            pFlags |= Pattern.CASE_INSENSITIVE;
        } else if ("MULTILINE".equals(s)) {
            pFlags |= Pattern.MULTILINE;
        } else if ("DOTALL".equals(s)) {
            pFlags |= Pattern.DOTALL;
        } else if ("UNICODE_CASE".equals(s)) {
            pFlags |= Pattern.UNICODE_CASE;
        } else if ("CANON_EQ".equals(s)) {
            pFlags |= Pattern.CANON_EQ;
        } else if ("UNIX_LINES".equals(s)) {
            pFlags |= Pattern.UNIX_LINES;
        } else if ("LITERAL".equals(s)) {
            pFlags |= Pattern.LITERAL;
        } else if ("COMMENTS".equals(s)) {
            pFlags |= Pattern.COMMENTS;
        } else if (("UNICODE_CHAR_CLASS".equals(s)) || ("UNICODE_CHARACTER_CLASS".equals(s))) {
            pFlags |= UNICODE_CHARACTER_CLASS;
        } else {
            throw new IllegalArgumentException("Unknown regex flag [" + s + "]");
        }
    }
    return pFlags;
}
 

public static String flagsToString(int flags) {
    StringBuilder sb = new StringBuilder();
    if ((flags & Pattern.CASE_INSENSITIVE) != 0) {
        sb.append("CASE_INSENSITIVE|");
    }
    if ((flags & Pattern.MULTILINE) != 0) {
        sb.append("MULTILINE|");
    }
    if ((flags & Pattern.DOTALL) != 0) {
        sb.append("DOTALL|");
    }
    if ((flags & Pattern.UNICODE_CASE) != 0) {
        sb.append("UNICODE_CASE|");
    }
    if ((flags & Pattern.CANON_EQ) != 0) {
        sb.append("CANON_EQ|");
    }
    if ((flags & Pattern.UNIX_LINES) != 0) {
        sb.append("UNIX_LINES|");
    }
    if ((flags & Pattern.LITERAL) != 0) {
        sb.append("LITERAL|");
    }
    if ((flags & Pattern.COMMENTS) != 0) {
        sb.append("COMMENTS|");
    }
    if ((flags & UNICODE_CHARACTER_CLASS) != 0) {
        sb.append("UNICODE_CHAR_CLASS|");
    }
    return sb.toString();
}
 

private int joniToPatternFlags(int flags) {
  int newFlags = 0;
  if ((flags & Option.IGNORECASE) != 0) {
    newFlags |= Pattern.CASE_INSENSITIVE;
  }
  // This does NOT mean Pattern.MULTILINE, this is equivalent to Pattern.DOTALL
  if ((flags & Option.MULTILINE) != 0) {
    newFlags |= Pattern.DOTALL;
  }
  // This means Pattern.MULTILINE. Nice
  if ((flags & Option.NEGATE_SINGLELINE) != 0) {
    newFlags |= Pattern.MULTILINE;
  }
  return newFlags;
}
 

private Pattern compilePattern(String sectionName) {
    int flags = Pattern.DOTALL | Pattern.MULTILINE;
    return Pattern.compile(".*^\\s*?//\\s*?KEEP " + sectionName + ".*?\n(.*?)^\\s*// KEEP " + sectionName
            + " END.*?\n", flags);
}
 

/**
 * Constructor
 * Adds Pattern.DOTALL to the underlying Pattern
 * @param expr a valid regular expression
 */
public RegexStringComparator(String expr) {
  this(expr, Pattern.DOTALL);
}