Java Code Examples for java.util.regex.MatchResult#end()

@Override
public void annotate(@NotNull final PsiElement element, @NotNull AnnotationHolder holder) {
  if (element instanceof DustOpenTag) {
    DustOpenTag openTag = (DustOpenTag) element;
    checkMatchingCloseTag(openTag, holder);
  }

  if (element.getNode().getElementType() == DustTypes.COMMENT) {
    String commentStr = element.getText();

    if (commentStr.length() >= 8) {
      commentStr = commentStr.substring(0, commentStr.length() - 2);
      Pattern p = Pattern.compile("TODO[^\n]*");
      Matcher m = p.matcher(commentStr);

      int startOffset = element.getTextRange().getStartOffset();
      while (m.find()) {
        MatchResult mr = m.toMatchResult();
        TextRange tr = new TextRange(startOffset + mr.start(), startOffset + mr.end());
        holder.createInfoAnnotation(tr, null).setTextAttributes(DustSyntaxHighlighter.TODO);
      }
    }
  }
}
 

int skipQuoted(String line, Matcher quote, MatchResult q) {
    // First is a quote, skip until next (not escaped) quote is seen
    int p = q.end();
    int p1 = quoteRestart(q);
    MatchResult q1 = find(quote, p1);
    if (q1 == null) {
        // No more quotes in the line, we are inside a string not closed in this line
        eventHandler.onQuoted(line.substring(p), true, false);
        isInsideString = true;
        p = line.length();
    } else {
        // Emit this string and advance
        eventHandler.onQuoted(line.substring(p, quoteStart(q1)), true, true);
        p = q1.end();
    }
    return p;
}
 

int skipBlockComment(String line, Matcher blockCommentEnd, MatchResult bcs) {
    // We go through a block comment start and look for a block comment end
    int p = bcs.end();
    MatchResult bce = find(blockCommentEnd, p);
    if (bce == null) {
        // No block comment end found in this line, start a multi-line comment
        eventHandler.onBlockComment(line.substring(p), true, false);
        isInsideBlockComment = true;
        p = line.length();
    } else {
        // Emit this block comment and advance
        eventHandler.onBlockComment(line.substring(p, bce.start()), true, true);
        p = bce.end();
    }
    return p;
}
 

/**
 * Parse the given filter string and return transformed filter expression.
 *
 * <p>Automatically calculate <code>LEFT JOIN</code> for association path expressions and the
 * path expressions are replaced with the join variables.
 *
 * @param filter the filter expression
 * @return the transformed filter expression
 */
private String parse(String filter) {

  String result = "";
  Matcher matcher = pathPattern.matcher(filter);

  int last = 0;
  while (matcher.find()) {
    MatchResult matchResult = matcher.toMatchResult();
    String alias = joinName(matchResult.group(1));
    if (alias == null) {
      alias = "self." + matchResult.group(1);
    }
    result += filter.substring(last, matchResult.start()) + alias;
    last = matchResult.end();
  }
  if (last < filter.length()) result += filter.substring(last);

  return result;
}
 

/**
 * Check whether the part of speech constraint defined in a rule is satisfied.
 * 
 * @param s
 * @param posConstraint
 * @param m
 * @param jcas
 * @return
 */
public boolean checkPosConstraint(Sentence s, String posConstraint, MatchResult m, JCas jcas) {
	Pattern paConstraint = Pattern.compile("group\\(([0-9]+)\\):(.*?):");
	for (MatchResult mr : Toolbox.findMatches(paConstraint, posConstraint)) {
		int groupNumber = Integer.parseInt(mr.group(1));
		int tokenBegin = s.getBegin() + m.start(groupNumber);
		int tokenEnd = s.getBegin() + m.end(groupNumber);
		String pos = mr.group(2);
		String pos_as_is = getPosFromMatchResult(tokenBegin, tokenEnd, s, jcas);
		if (pos_as_is.matches(pos)) {
			Logger.printDetail("POS CONSTRAINT IS VALID: pos should be " + pos + " and is " + pos_as_is);
		} else {
			return false;
		}
	}
	return true;
}
 

/**
 * Do a content substitution by looking at the array size and looking for {0}...{n} strings and replace them with
 * the array's content.<br>
 * (Note - we use this method and not the NLS.bind() because it does not handle well code blocks existence)
 * 
 * @param content
 * @param substitutions
 * @return A string, substituted with the array's content.
 */
private static String substitute(String content, String[] substitutions)
{
	StringBuilder buffer = new StringBuilder(content);
	Matcher matcher = SUBSTITUTION_PATTERN.matcher(content);
	int offset = 0;
	while (matcher.find())
	{
		MatchResult matchResult = matcher.toMatchResult();
		int beginIndex = matchResult.start();
		int endIndex = matchResult.end();
		int index = Integer.parseInt(content.substring(beginIndex + 1, endIndex - 1));
		if (index >= 0 && index < substitutions.length)
		{
			String replacement = substitutions[index];
			int matchLength = endIndex - beginIndex;
			buffer.replace(offset + beginIndex, offset + endIndex, replacement);
			offset += (replacement.length() - matchLength);
		}
	}
	return buffer.toString();
}
 

public String replaceMatches(CharSequence charSequence, Callback callback) throws CallbackMatcherException {
    StringBuilder result = new StringBuilder(charSequence);
    final Matcher matcher = this.pattern.matcher(charSequence);
    int offset = 0;

    while (matcher.find()) {
        final MatchResult matchResult = matcher.toMatchResult();
        final String replacement = callback.foundMatch(matchResult);
        if (replacement == null) {
            continue;
        }

        int matchStart = offset + matchResult.start();
        int matchEnd = offset + matchResult.end();

        result.replace(matchStart, matchEnd, replacement);

        int matchLength = matchResult.end() - matchResult.start();
        int lengthChange = replacement.length() - matchLength;

        offset += lengthChange;
    }

    return result.toString();
}
 

/**
 * Check token boundaries of expressions.
 * 
 * @param r
 *            MatchResult
 * @param s
 *            Respective sentence
 * @return whether or not the MatchResult is a clean one
 */
public static Boolean checkInfrontBehind(MatchResult r, Sentence s) {
	Boolean ok = true;

	// get rid of expressions such as "1999" in 53453.1999
	if (r.start() > 1) {
		if ((s.getCoveredText().substring(r.start() - 2, r.start()).matches("\\d\\."))) {
			ok = false;
		}
	}

	// get rid of expressions if there is a character or symbol ($+)
	// directly in front of the expression
	if (r.start() > 0) {
		if (((s.getCoveredText().substring(r.start() - 1, r.start()).matches("[\\w\\$\\+]")))
				&& (!(s.getCoveredText().substring(r.start() - 1, r.start()).matches("\\(")))) {
			ok = false;
		}
	}

	if (r.end() < s.getCoveredText().length()) {
		if ((s.getCoveredText().substring(r.end(), r.end() + 1).matches("[°\\w]"))
				&& (!(s.getCoveredText().substring(r.end(), r.end() + 1).matches("\\)")))) {
			ok = false;
		}
		if (r.end() + 1 < s.getCoveredText().length()) {
			if (s.getCoveredText().substring(r.end(), r.end() + 2).matches("[\\.,]\\d")) {
				ok = false;
			}
		}
	}
	return ok;
}
 

private int updateStateAfterFound(MatchResult matchResult, int offset) {
    int end = matchResult.end() + offset;
    int found = matchResult.start() + offset; 
    
    target.select(found, end);
    target.getCaret().setSelectionVisible(true);
    
    // update state variables
    lastFoundIndex = found;
    lastMatchResult = matchResult;
    lastRegex = ((Matcher) lastMatchResult).pattern().pattern();
    
    return found;
}
 

public String replace(Function1<? super CharSequence, ? extends CharSequence> notMatched, Function1<? super MatchResult, ? extends CharSequence> matched) {
    StringBuilder builder = new StringBuilder();
    int position = 0;
    for (MatchResult matchResult : this) {
        CharSequence before = text.subSequence(position, matchResult.start());
        if (before.length() > 0) builder.append(filterNull(call(notMatched, before)));
        builder.append(filterNull(call(matched, (matchResult))));
        position = matchResult.end();
    }
    CharSequence after = text.subSequence(position, text.length());
    if (after.length() > 0) builder.append(filterNull(call(notMatched, after)));
    return builder.toString();
}
 

public String replaceVariables(String raw) throws Exception {
    if (raw == null) {
        return null;
    }

    Matcher matcher = PATTERN.matcher(raw);
    StringBuilder replaced = new StringBuilder();

    int cur = 0;

    while (matcher.find()) {
        MatchResult result = matcher.toMatchResult();

        replaced.append(raw.substring(cur, result.start(1)));

        String name = result.group(2);
        Object value = this.supplier.valueOf(name);
        if (value == null) {
            value = "${" + name + "}";
        }
        replaced.append(value);

        cur = result.end();
    }

    replaced.append(raw.substring(cur));

    return replaced.toString();
}
 

int quoteRestart(MatchResult q) {
    // If we want to restart the search for quotes from current result we must start search from end - 1
    // because the regular expression for searching quotes looks for sequence non-quote + quote
    // This fix allows to match empty quoted strings
    // Only when end > 1, re-starting from 1 is wrong
    return q.end() > 1 ? q.end() - 1 : q.end();
}
 

int skipStart(String line, Matcher quote, Matcher blockCommentEnd) {
    MatchResult m = null;
    if (isInsideString) {
        m = find(quote, 0);
    } else if (isInsideBlockComment) {
        m = find(blockCommentEnd, 0);
    }

    int p = 0;
    if (m != null) {
        // If we were inside block comment emit a block comment, remove the flag
        if (isInsideBlockComment) {
            if (m.start() > 0) {
                eventHandler.onBlockComment(line.substring(0, m.start()), false, true);
            }
            isInsideBlockComment = false;
        } else if (isInsideString) {
            // If we were inside string emit a quoted string, remove the flag
            if (m.start() > 0) {
                eventHandler.onQuoted(line.substring(0, quoteStart(m)), false, true);
            }
            isInsideString = false;
        }
        p = m.end();
    }
    return p;
}
 

private String replaceStrings(List<MatchResult> results, String document) {
    StringBuffer sb = new StringBuffer(document);
    for(MatchResult m : results) {
        int startOffset =m.start();
        int endOffset = m.end();
        StringBuffer outputBuffer = new StringBuffer();
        for (int i = 0; i < (endOffset - startOffset); i++) {
            outputBuffer.append("X");
        }
        sb.replace(startOffset, endOffset, outputBuffer.toString());
    }
    return sb.toString();
}
 

/**
 * Attempt to match a complete address in content, starting with
 * houseNumberMatch.
 *
 * @param content The string to search.
 * @param houseNumberMatch A matching house number to start extending.
 * @return +ve: the end of the match
 *         +ve: the position to restart searching for house numbers, negated.
 */
private static int attemptMatch(String content, MatchResult houseNumberMatch) {
    int restartPos = -1;
    int nonZipMatch = -1;
    int it = houseNumberMatch.end();
    int numLines = 1;
    boolean consecutiveHouseNumbers = true;
    boolean foundLocationName = false;
    int wordCount = 1;
    String lastWord = "";

    Matcher matcher = sWordRe.matcher(content);

    for (; it < content.length(); lastWord = matcher.group(0), it = matcher.end()) {
        if (!matcher.find(it)) {
            // No more words in the input sequence.
            return -content.length();
        }
        if (matcher.end() - matcher.start() > kMaxAddressNameWordLength) {
            // Word is too long to be part of an address. Fail.
            return -matcher.end();
        }

        // Count the number of newlines we just consumed.
        while (it < matcher.start()) {
            if (NL.indexOf(content.charAt(it++)) != -1) ++numLines;
        }

        // Consumed too many lines. Fail.
        if (numLines > MAX_ADDRESS_LINES) break;

        // Consumed too many words. Fail.
        if (++wordCount > MAX_ADDRESS_WORDS) break;

        if (matchHouseNumber(content, it) != null) {
            if (consecutiveHouseNumbers && numLines > 1) {
                // Last line ended with a number, and this this line starts with one.
                // Restart at this number.
                return -it;
            }
            // Remember the position of this match as the restart position.
            if (restartPos == -1) restartPos = it;
            continue;
        }

        consecutiveHouseNumbers = false;

        if (isValidLocationName(matcher.group(0))) {
            foundLocationName = true;
            continue;
        }

        if (wordCount == MAX_LOCATION_NAME_DISTANCE && !foundLocationName) {
            // Didn't find a location name in time. Fail.
            it = matcher.end();
            break;
        }

        if (foundLocationName && wordCount > MIN_ADDRESS_WORDS) {
            // We can now attempt to match a state.
            MatchResult stateMatch = matchState(content, it);
            if (stateMatch != null) {
                if (lastWord.equals("et") && stateMatch.group(0).equals("al")) {
                    // Reject "et al" as a false postitive.
                    it = stateMatch.end();
                    break;
                }

                // At this point we've matched a state; try to match a zip code after it.
                Matcher zipMatcher = sWordRe.matcher(content);
                if (zipMatcher.find(stateMatch.end())) {
                    if (isValidZipCode(zipMatcher.group(0), stateMatch)) {
                        return zipMatcher.end();
                    }
                } else {
                    // The content ends with a state but no zip
                    // code. This is a legal match according to the
                    // documentation. N.B. This is equivalent to the
                    // original c++ implementation, which only allowed
                    // the zip code to be optional at the end of the
                    // string, which presumably is a bug.  We tried
                    // relaxing this to work in other places but it
                    // caused too many false positives.
                    nonZipMatch = stateMatch.end();
                }
            }
        }
    }

    if (nonZipMatch > 0) return nonZipMatch;

    return -(restartPos > 0 ? restartPos : it);
}
 

/**
 * Check token boundaries using token information
 * 
 * @param r
 *            MatchResult
 * @param s
 *            respective Sentence
 * @param jcas
 *            current CAS object
 * @return whether or not the MatchResult is a clean one
 */
public static Boolean checkTokenBoundaries(MatchResult r, Sentence s, JCas jcas) {
	Boolean beginOK = false;
	Boolean endOK = false;

	// whole expression is marked as a sentence
	if ((r.end() - r.start()) == (s.getEnd() - s.getBegin())) {
		return true;
	}

	// Only check Token boundaries if no white-spaces in front of and behind
	// the match-result
	if ((r.start() > 0) && ((s.getCoveredText().subSequence(r.start() - 1, r.start()).equals(" ")))
			&& ((r.end() < s.getCoveredText().length())
					&& ((s.getCoveredText().subSequence(r.end(), r.end() + 1).equals(" "))))) {
		return true;
	}

	// other token boundaries than white-spaces
	else {
		FSIterator iterToken = jcas.getAnnotationIndex(Token.type).subiterator(s);
		while (iterToken.hasNext()) {
			Token t = (Token) iterToken.next();

			// Check begin
			if ((r.start() + s.getBegin()) == t.getBegin()) {
				beginOK = true;
			}
			// Tokenizer does not split number from some symbols (".", "/",
			// "-", "–"),
			// e.g., "...12 August-24 Augsut..."
			else if ((r.start() > 0) && ((s.getCoveredText().subSequence(r.start() - 1, r.start()).equals("."))
					|| (s.getCoveredText().subSequence(r.start() - 1, r.start()).equals("/"))
					|| (s.getCoveredText().subSequence(r.start() - 1, r.start()).equals("–"))
					|| (s.getCoveredText().subSequence(r.start() - 1, r.start()).equals("-")))) {
				beginOK = true;
			}

			// Check end
			if ((r.end() + s.getBegin()) == t.getEnd()) {
				endOK = true;
			}
			// Tokenizer does not split number from some symbols (".", "/",
			// "-", "–"),
			// e.g., "... in 1990. New Sentence ..."
			else if ((r.end() < s.getCoveredText().length())
					&& ((s.getCoveredText().subSequence(r.end(), r.end() + 1).equals("."))
							|| (s.getCoveredText().subSequence(r.end(), r.end() + 1).equals("/"))
							|| (s.getCoveredText().subSequence(r.end(), r.end() + 1).equals("–"))
							|| (s.getCoveredText().subSequence(r.end(), r.end() + 1).equals("-")))) {
				endOK = true;
			}

			if (beginOK && endOK)
				return true;
		}
	}
	return false;
}
 

/**
 * <p>Create a new {@link #PercentConversion} instance.</p>
 * 
 * <p>A <tt>PercentConversion</tt> instance is created from one
 * particular specifier match result and is fixed after creation.</p>
 * 
 * This is because for some format strings, it is expected that 
 * multiple <tt>PercentConversions</tt> will be needed to fully convert
 * the format string and each <tt>PercentConversion</tt> should represent
 * one specifier and one specifier only in the format string.
 * 
 * @param aConverter - the enclosing {@link #PercentToBraceConverter} instance
 * @param aMatch - a specific {@link java.util.regex#MatchResult MatchResult} that holds 
 *                 information about the matched specifier token.
 * @throws IllegalArgumentException
 *          if <tt>aConverter</tt> or <tt>aMatch</tt> is <tt>null</tt>
 *          
 * @throws IllegalStateException 
 *          if <tt>aMatch</tt> is passed before a successful match could be made
 *          it is said to have inconsistent state.
 */
public PercentConversion(PercentToBraceConverter aConverter, MatchResult aMatch)
        throws IllegalArgumentException, IllegalStateException {

    if (null == aConverter) {
        throw new IllegalArgumentException("Converter can't be null!");
    }
    if (null == aMatch) {
        throw new IllegalArgumentException("Match can't be null!");
    }

    source = aMatch.group(0);
    span = new int[] { aMatch.start(), aMatch.end() };

    final Map<String, String> groups = extractTokenGroups(aMatch);

    String spec = groups.get("Key");
    if (null == spec) {
        if ("%%".equals(source)) {
            key = "";
        } else {
            key = aConverter.nextIndex();
        }
    } else {
        key = spec;
    }

    spec = groups.get("Width");
    if (null != spec && "*".equals(spec)) {
        // TODO: {} representation is hard-wired, could generalize this if needed
        width = String.format("{%s}", aConverter.nextIndex());
    } else {
        width = spec;
    }

    spec = groups.get("Precision");
    if (null != spec && "*".equals(spec)) {
        precision = String.format("{%s}", aConverter.nextIndex());
    } else {
        precision = spec;
    }

    flags = groups.get("Flags");
    conversion = groups.get("Conversion");
}
 

void scan(String line) {
    // We will allow comment characters inside a constant string
    // We will also quoted strings inside a comment
    // We will emit block comments that span multiple lines as a sequence of comment blocks, one for every line
    // Same for multiple line quoted strings

    Matcher quote = quoteRegex.matcher(line);
    Matcher lineComment = lineCommentRegex.matcher(line);
    Matcher blockCommentStart = blockCommentStartRegex.matcher(line);
    Matcher blockCommentEnd = blockCommentEndRegex.matcher(line);

    // Look for the line starting point, taking into account special situations where
    // we are inside a string, line really begins at first occurrence of quote character (if it occurs in the line)
    // we are inside a block comment, line really begins at first occurrence of block comment end (if it occurs in the line)
    int p = skipStart(line, quote, blockCommentEnd);

    // If after skipping the start we continue inside a block comment emit whole line as a block comment and finish
    // Similar if we are still (totally) inside a string, emit whole line as a string and finish scan
    if (isInsideBlockComment) {
        eventHandler.onBlockComment(line, false, false);
        return;
    }
    if (isInsideString) {
        eventHandler.onQuoted(line, false, false);
        return;
    }

    // Go across the line
    while (p < line.length()) {
        MatchResult q;
        MatchResult bcs;
        MatchResult lc;

        // From current position find first of occurrence of {string start, block comment start, line comment start}
        q = find(quote, p);
        bcs = find(blockCommentStart, p);
        lc = find(lineComment, p);

        // Check what comes first
        boolean isQuote = q != null && (bcs == null || q.start() < bcs.start()) && (lc == null || q.start() < lc.start());
        boolean isBlockComment = bcs != null && (q == null || bcs.start() < q.start()) && (lc == null || bcs.start() < lc.start());
        boolean isLineComment = lc != null && (q == null || lc.start() < q.start()) && (bcs == null || lc.start() < bcs.start());

        if (isQuote) {
            // Emit as text from last pointer to here
            if (q.start() > 0) {
                eventHandler.onText(line.substring(p, quoteStart(q)));
            }
            p = skipQuoted(line, quote, q);
        } else if (isBlockComment) {
            // Emit as text from last pointer to here
            if (bcs.start() > 0) {
                eventHandler.onText(line.substring(p, bcs.start()));
            }
            p = skipBlockComment(line, blockCommentEnd, bcs);
        } else if (isLineComment) {
            if (lc.start() > 0) {
                eventHandler.onText(line.substring(p, lc.start()));
            }
            if (lc.end() < line.length()) {
                eventHandler.onLineComment(line.substring(lc.end()));
            }
            break;
        } else {
            // Emit the rest of the line as text and finish
            eventHandler.onText(line.substring(p));
            break;
        }
    }
}