import edu.stanford.nlp.trees.tregex.TregexPatternCompiler; //导入依赖的package包/类
public TransformationRuleGroups(String ruleFile)
    throws FileNotFoundException, IOException {
  patternCompiler = new TregexPatternCompiler();
  RuleGroups.Builder rulesBuilder = RuleGroups.newBuilder();
  TextFormat.merge(new FileReader(ruleFile), rulesBuilder);
  RuleGroups ruleGroups = rulesBuilder.build();

  ruleGroupList = new ArrayList<>();
  for (RuleGroup ruleGroup : ruleGroups.getRulegroupList()) {
    TransformationRuleGroup transformationRuleGroup =
        new TransformationRuleGroup(ruleGroup);
    ruleGroupList.add(transformationRuleGroup);
  }
  
  // Sort the groups based on the priority.
  ruleGroupList.sort(Comparator.comparing(r -> r.getPriority()));

  // Create relation priority map.
  relationPriority = new HashMap<>();
  relationList = new ArrayList<>(ruleGroups.getRelationList());
  relationList.sort(Comparator.comparing(r -> r.getPriority()));

  relationList.forEach(relation -> relationPriority.put(relation.getName(),
      relation.getPriority()));
}
 

import edu.stanford.nlp.trees.tregex.TregexPatternCompiler; //导入依赖的package包/类
/**
 * Similar to {@link Rule} but with cache to store tregex patterns.
 * 
 * @param ruleGroup
 */
public TransformationRule(Rule rule) {

  if (rule.hasPriority())
    priority = rule.getPriority();

  if (rule.hasName())
    name = rule.getName();

  if (rule.hasTregex()) {
    tregex = TregexPatternCompiler.defaultCompiler.compile(rule.getTregex());
  }

  transformationList = new ArrayList<>(rule.getTransformationList());
}
 

import edu.stanford.nlp.trees.tregex.TregexPatternCompiler; //导入依赖的package包/类
/**
 * Parses a tsurgeon script text input and compiles a tregex pattern and a list
 * of tsurgeon operations into a pair.
 *
 * @param reader Reader to read patterns from
 * @return A pair of a tregex and tsurgeon pattern read from a file, or <code>null</code>
 *    when the operations in the Reader have been exhausted
 * @throws IOException If any IO problem
 */
public static Pair<TregexPattern, TsurgeonPattern> getOperationFromReader(BufferedReader reader, TregexPatternCompiler compiler) throws IOException {
  String patternString = getTregexPatternFromReader(reader);
  // System.err.println("Read tregex pattern: " + patternString);
  if ("".equals(patternString)) {
    return null;
  }
  TregexPattern matchPattern = compiler.compile(patternString);

  TsurgeonPattern collectedPattern = getTsurgeonOperationsFromReader(reader);
  return new Pair<TregexPattern,TsurgeonPattern>(matchPattern,collectedPattern);
}
 

import edu.stanford.nlp.trees.tregex.TregexPatternCompiler; //导入依赖的package包/类
/**
 * Parses a tsurgeon script file and compiles all operations in the file into a list
 * of pairs of tregex and tsurgeon patterns.
 *
 * @param filename file containing the tsurgeon script
 * @return A pair of a tregex and tsurgeon pattern read from a file
 * @throws IOException If there is any I/O problem
 */
public static List<Pair<TregexPattern, TsurgeonPattern>> getOperationsFromFile(String filename, String encoding, TregexPatternCompiler compiler) throws IOException {
  List<Pair<TregexPattern,TsurgeonPattern>> operations = new ArrayList<Pair<TregexPattern, TsurgeonPattern>>();
  BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), encoding));
  for ( ; ; ) {
    Pair<TregexPattern, TsurgeonPattern> operation = getOperationFromReader(reader, compiler);
    if (operation == null) {
      break;
    }
    operations.add(operation);
  }
  reader.close();
  return operations;
}
 

import edu.stanford.nlp.trees.tregex.TregexPatternCompiler; //导入依赖的package包/类
public GrammaticalRelation(Language language,
                           String shortName,
                           String longName,
                           Class<? extends GrammaticalRelationAnnotation> annotation,
                           GrammaticalRelation parent,
                           String sourcePattern,
                           TregexPatternCompiler tregexCompiler,
                           String[] targetPatterns) {
  this(language, shortName, longName, annotation, parent, sourcePattern, tregexCompiler, targetPatterns, null);
}