Java RuleMatch.setSuggestedReplacements方法代码示例

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
protected List<RuleMatch> getRuleMatches(String word, int startPos, AnalyzedSentence sentence) throws IOException {
  List<RuleMatch> ruleMatches = new ArrayList<>();
  if (isMisspelled(speller1, word) || isProhibited(word)) {
    RuleMatch ruleMatch = new RuleMatch(this, sentence, startPos, startPos
        + word.length(), messages.getString("spelling"),
        messages.getString("desc_spelling_short"));
    List<String> suggestions = speller1.getSuggestions(word);
    if (suggestions.isEmpty() && word.length() >= 5) {
      // speller1 uses a maximum edit distance of 1, it won't find suggestion for "garentee", "greatful" etc.
      suggestions.addAll(speller2.getSuggestions(word));
      if (suggestions.isEmpty()) {
        suggestions.addAll(speller3.getSuggestions(word));
      }
    }
    suggestions.addAll(0, getAdditionalTopSuggestions(suggestions, word));
    suggestions.addAll(getAdditionalSuggestions(suggestions, word));
    if (!suggestions.isEmpty()) {
      filterSuggestions(suggestions);
      ruleMatch.setSuggestedReplacements(orderSuggestions(suggestions, word));
    }
    ruleMatches.add(ruleMatch);
  }
  return ruleMatches;
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@Override
protected List<RuleMatch> getRuleMatches(String word, int startPos, AnalyzedSentence sentence) throws IOException {
  List<RuleMatch> ruleMatches = super.getRuleMatches(word, startPos, sentence);
  if (ruleMatches.size() > 0) {
    // so 'word' is misspelled: 
    IrregularForms forms = getIrregularFormsOrNull(word);
    if (forms != null) {
      RuleMatch oldMatch = ruleMatches.get(0);
      RuleMatch newMatch = new RuleMatch(this, sentence, oldMatch.getFromPos(), oldMatch.getToPos(), 
              "Possible spelling mistake. Did you mean <suggestion>" + forms.forms.get(0) +
              "</suggestion>, the " + forms.formName + " form of the " + forms.posName +
              " '" + forms.baseform + "'?");
      List<String> allSuggestions = new ArrayList<>();
      allSuggestions.addAll(forms.forms);
      for (String repl : oldMatch.getSuggestedReplacements()) {
        if (!allSuggestions.contains(repl)) {
          allSuggestions.add(repl);
        }
      }
      newMatch.setSuggestedReplacements(allSuggestions);
      ruleMatches.set(0, newMatch);
    }
  }
  return ruleMatches;
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@Override
protected RuleMatch createRuleMatch(String prevToken, String token, int prevPos, int pos, String msg, AnalyzedSentence sentence) {
  boolean doubleI = prevToken.equals("І") && token.equals("і");
  if( doubleI ) {
    msg += " або, можливо, перша І має бути латинською.";
  }
  
  RuleMatch ruleMatch = super.createRuleMatch(prevToken, token, prevPos, pos, msg, sentence);

  if( doubleI ) {
    List<String> replacements = new ArrayList<>(ruleMatch.getSuggestedReplacements());
    replacements.add("I і");
    ruleMatch.setSuggestedReplacements(replacements);
  }
  return ruleMatch;
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@Override
public RuleMatch[] match(AnalyzedSentence sentenceObj) throws IOException {
  String sentence = sentenceObj.getText();
  Matcher matcher = pattern.matcher(sentence);
  int startPos = 0;
  List<RuleMatch> matches = new ArrayList<>();
  while (matcher.find(startPos)) {
    String msg = replaceBackRefs(matcher, message);
    boolean sentenceStart = matcher.start(0) == 0;
    List<String> suggestions = extractSuggestions(matcher, msg);
    List<String> matchSuggestions = getMatchSuggestions(sentence, matcher);
    msg = replaceMatchElements(msg, matchSuggestions);
    int markStart = matcher.start(markGroup);
    int markEnd = matcher.end(markGroup);
    RuleMatch ruleMatch = new RuleMatch(this, sentenceObj, markStart, markEnd, msg, null, sentenceStart, null);
    List<String> allSuggestions = new ArrayList<>();
    if (matchSuggestions.size() > 0) {
      allSuggestions.addAll(matchSuggestions);
    } else {
      allSuggestions.addAll(suggestions);
      List<String> extendedSuggestions = extractSuggestions(matcher, getSuggestionsOutMsg());
      allSuggestions.addAll(extendedSuggestions);
    }
    ruleMatch.setSuggestedReplacements(allSuggestions);
    matches.add(ruleMatch);
    startPos = matcher.end();
  }
  return matches.toArray(new RuleMatch[matches.size()]);
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@Override
public RuleMatch[] match(AnalyzedSentence sentence) {
  List<RuleMatch> ruleMatches = new ArrayList<>();
  AnalyzedTokenReadings[] tokens = sentence.getTokensWithoutWhitespace();
  AnalyzedTokenReadings[] tokensWithWS = sentence.getTokens();

  String prevToken = "";
  // we start from token 1, token 0 is SENT_START 
  for (int i = 1; i < tokens.length; i++) {
    String token = tokens[i].getToken();
    if (isWord(token) && prevToken.equalsIgnoreCase(token) && !ignore(sentence, tokensWithWS, i)) {
      int prevPos = tokens[i - 1].getStartPos();
      int pos = tokens[i].getStartPos();
      RuleMatch ruleMatch = new RuleMatch(this, sentence, prevPos, pos+prevToken.length(),
              messages.getString("repetition"),
              messages.getString("desc_repetition_short"));
      List<String> replacements = new ArrayList<>();
      replacements.add(prevToken + " " + token); // case 1: replace zero-width space w/ real space 
      replacements.add(prevToken);               // case 2: remove repeated word - same as original suggestion 
      replacements.add(prevToken + "ៗ");        // case 3: same as case 2, just add "repetition character"
      ruleMatch.setSuggestedReplacements(replacements);
      ruleMatches.add(ruleMatch);
    }
    prevToken = token;
  }

  return toRuleMatchArray(ruleMatches);
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
private RuleMatch createRuleMatch(AnalyzedTokenReadings readings, AnalyzedSentence sentence) {
  String tokenString = readings.getToken();
  String replacement = tokenString.replace(HIDDEN_CHAR.toString(), "");
  String msg = tokenString + getSuggestion(tokenString) + replacement;

  RuleMatch potentialRuleMatch = new RuleMatch(this, sentence, readings.getStartPos(), readings.getEndPos(), msg, getShort());
  potentialRuleMatch.setSuggestedReplacements(Arrays.asList(replacement));

  return potentialRuleMatch;
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@Override
public RuleMatch[] match(AnalyzedSentence sentence) throws IOException {
  List<RuleMatch> ruleMatches = new ArrayList<>();
  if (needsInit) {
    init();
  }
  if (hunspellDict == null) {
    // some languages might not have a dictionary, be silent about it
    return toRuleMatchArray(ruleMatches);
  }
  String[] tokens = tokenizeText(getSentenceTextWithoutUrlsAndImmunizedTokens(sentence));

  // starting with the first token to skip the zero-length START_SENT
  int len = sentence.getTokens()[1].getStartPos();
  for (int i = 0; i < tokens.length; i++) {
    String word = tokens[i];
    if (ignoreWord(Arrays.asList(tokens), i) || ignoreWord(word)) {
      len += word.length() + 1;
      continue;
    }
    if (isMisspelled(word)) {
      RuleMatch ruleMatch = new RuleMatch(this, sentence,
          len, len + word.length(),
          messages.getString("spelling"),
          messages.getString("desc_spelling_short"));
      List<String> suggestions = getSuggestions(word);
      List<String> additionalTopSuggestions = getAdditionalTopSuggestions(suggestions, word);
      Collections.reverse(additionalTopSuggestions);
      for (String additionalTopSuggestion : additionalTopSuggestions) {
        if (!word.equals(additionalTopSuggestion)) {
          suggestions.add(0, additionalTopSuggestion);
        }
      }
      List<String> additionalSuggestions = getAdditionalSuggestions(suggestions, word);
      for (String additionalSuggestion : additionalSuggestions) {
        if (!word.equals(additionalSuggestion)) {
          suggestions.addAll(additionalSuggestions);
        }
      }
      if (!suggestions.isEmpty()) {
        filterSuggestions(suggestions);
        filterDupes(suggestions);
        ruleMatch.setSuggestedReplacements(suggestions);
      }
      ruleMatches.add(ruleMatch);
    }
    len += word.length() + 1;
  }
  return toRuleMatchArray(ruleMatches);
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
private RuleMatch createRuleMatch(AnalyzedTokenReadings readings, List<String> replacements, String msg, AnalyzedSentence sentence) {
  RuleMatch potentialRuleMatch = new RuleMatch(this, sentence, readings.getStartPos(), readings.getEndPos(), msg, "Перейменована назва");
  potentialRuleMatch.setSuggestedReplacements(replacements);

  return potentialRuleMatch;
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
private RuleMatch createRuleMatch(AnalyzedTokenReadings readings, List<String> replacements, String msg, AnalyzedSentence sentence) {
  RuleMatch potentialRuleMatch = new RuleMatch(this, sentence, readings.getStartPos(), readings.getEndPos(), msg, getShort());
  potentialRuleMatch.setSuggestedReplacements(replacements);

  return potentialRuleMatch;
}