import edu.stanford.nlp.util.Function; //导入依赖的package包/类
@Override
public Tree transformTree(Tree t, Tree root) {

  StringBuilder newCategory = new StringBuilder(t.label().value());
  for (Map.Entry<TregexPattern,Function<TregexMatcher,String>> e : activeAnnotations.entrySet()) {
    TregexMatcher m = e.getKey().matcher(root);
    if (m.matchesAt(t)) {
      newCategory.append(e.getValue().apply(m));
      //      System.out.println("node match " + e.getValue()); //testing
      //      t.pennPrint(); //testing
    }
  }
  String newCat = newCategory.toString();
  t.label().setValue(newCat);
  // cdm Mar 2005: the equivalent of the below wasn't being done in the old
  // code, but it really needs to be!
  if (t.isPreTerminal()) {
    HasTag lab = (HasTag) t.label();
    lab.setTag(newCat);
  }
  //  t.pennPrint(); //testing

  return t;
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 * This method just tests the functionality of the included transformers.
 */
public static void main(String[] args) {
  //TreeFactory tf = new LabeledScoredTreeFactory();
  Tree stringyTree = null;
  try {
    stringyTree = (new PennTreeReader(new StringReader("(S (VP (VBZ Try) (NP (DT this))) (. .))"), new LabeledScoredTreeFactory(new StringLabelFactory()))).readTree();
  } catch (IOException e) {
  }
  System.out.println(stringyTree);
  Function<Tree, Tree> a = getLabeledTreeToCategoryWordTagTreeFunction();
  Tree adaptyTree = a.apply(stringyTree);
  System.out.println(adaptyTree);
  adaptyTree.percolateHeads(new CollinsHeadFinder());
  System.out.println(adaptyTree);

  Function<Tree, Tree> b = getLabeledTreeToStringLabeledTreeFunction();
  Tree stringLabelTree = b.apply(adaptyTree);
  System.out.println(stringLabelTree);

}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 *
 * @param arg This may have a ! and then maybe a @ and then either an
 *            identifier or regex
 */
UnbrokenCategoryDominates(String arg,
                          Function<String, String> basicCatFunction) {
  super("<+(" + arg + ')');
  if (arg.startsWith("!")) {
    negatedPattern = true;
    arg = arg.substring(1);
  } else {
    negatedPattern = false;
  }
  if (arg.startsWith("@")) {
    basicCat = true;
    this.basicCatFunction = basicCatFunction;
    arg = arg.substring(1);
  } else {
    basicCat = false;
  }
  if (arg.matches("/.*/")) {
    pattern = Pattern.compile(arg.substring(1, arg.length() - 1));
  } else if (arg.matches("__")) {
    pattern = Pattern.compile("^.*$");
  } else {
    pattern = Pattern.compile("^(?:" + arg + ")$");
  }
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 * This method just tests the functionality of the included transformers.
 */
public static void main(String[] args) {
  //TreeFactory tf = new LabeledScoredTreeFactory();
  Tree stringyTree = null;
  try {
    stringyTree = (new PennTreeReader(new StringReader("(S (VP (VBZ Try) (NP (DT this))) (. .))"), new LabeledScoredTreeFactory(new StringLabelFactory()))).readTree();
  } catch (IOException e) {
    // do nothing
  }
  System.out.println(stringyTree);
  Function<Tree, Tree> a = getLabeledTreeToCategoryWordTagTreeFunction();
  Tree adaptyTree = a.apply(stringyTree);
  System.out.println(adaptyTree);
  adaptyTree.percolateHeads(new CollinsHeadFinder());
  System.out.println(adaptyTree);

  Function<Tree, Tree> b = getLabeledTreeToStringLabeledTreeFunction();
  Tree stringLabelTree = b.apply(adaptyTree);
  System.out.println(stringLabelTree);

}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 * @param arg The pattern to match, perhaps preceded by ! and/or @
 */
UnbrokenCategoryFollows(String arg,
                        Function<String, String> basicCatFunction) {
  super(",+(" + arg + ')');
  if (arg.startsWith("!")) {
    negatedPattern = true;
    arg = arg.substring(1);
  } else {
    negatedPattern = false;
  }
  if (arg.startsWith("@")) {
    basicCat = true;
    this.basicCatFunction = basicCatFunction;
    arg = arg.substring(1);
  } else {
    basicCat = false;
  }
  if (arg.matches("/.*/")) {
    pattern = Pattern.compile(arg.substring(1, arg.length() - 1));
  } else if (arg.matches("__")) {
    pattern = Pattern.compile("^.*$");
  } else {
    pattern = Pattern.compile("^(?:" + arg + ")$");
  }
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
public DelimitRegExIterator(Reader r, String delimiter, Function<String,T> op) {
  this.op = op;
  BufferedReader in = new BufferedReader(r);
  try {
    String line;
    StringBuilder input = new StringBuilder();
    while ((line = in.readLine()) != null) {
      input.append(line).append("\n");
    }
    line = input.toString();
    Pattern p = Pattern.compile("^"+delimiter);
    Matcher m = p.matcher(line);
    line = m.replaceAll("");
    p = Pattern.compile(delimiter+"$");
    m = p.matcher(line);
    line = m.replaceAll("");
    line = line.trim();

    tokens = Arrays.asList(line.split(delimiter)).iterator();
  } catch (Exception e) {
  }
  setNext();
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 * @param arg The pattern to match, perhaps preceded by ! and/or @
 */
UnbrokenCategoryPrecedes(String arg,
                         Function<String, String> basicCatFunction) {
  super(".+(" + arg + ')');
  if (arg.startsWith("!")) {
    negatedPattern = true;
    arg = arg.substring(1);
  } else {
    negatedPattern = false;
  }
  if (arg.startsWith("@")) {
    basicCat = true;
    this.basicCatFunction = basicCatFunction; // todo -- this was missing a this. which must be testable in a unit test!!! Make one
    arg = arg.substring(1);
  } else {
    basicCat = false;
  }
  if (arg.matches("/.*/")) {
    pattern = Pattern.compile(arg.substring(1, arg.length() - 1));
  } else if (arg.matches("__")) {
    pattern = Pattern.compile("^.*$");
  } else {
    pattern = Pattern.compile("^(?:" + arg + ")$");
  }
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 * Annotate a collection of input annotations IN PARALLEL, making use of threads given in numThreads.
 * 
 * @param annotations
 *          The input annotations to process
 * @param numThreads
 *          The number of threads to run on
 */
public void annotate(final Iterable<Annotation> annotations, int numThreads) {
  annotate(annotations, numThreads, new Function<Annotation, Object>() {
    @Override
    public Object apply(Annotation in) {
      return null;
    }
  });
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
protected void tallyTreeIterator(Iterator<Tree> treeIterator, Function<Tree, Tree> f) {
  while (treeIterator.hasNext()) {
    Tree tree = treeIterator.next();
    try {
      tree = f.apply(tree);
    } catch (Exception e) {
      if (Test.verbose) {
        e.printStackTrace();
      }
    }
    tallyTree(tree);
  }
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 * Returns a list of sentences contained in an XML file, occuring between the begin and end of a selected tag.
 *
 * @param splitOnTag    the tag which denotes text boundaries
 * @param sentenceDelimiter The text that separates sentences
 * @param doPTBEscaping whether to escape PTB tokens using a {@link PTBEscapingProcessor}
 * @return A list of sentences contained in an XML file
 */
public List<List<? extends HasWord>> getSentencesFromXML(Reader input, String splitOnTag, String sentenceDelimiter, boolean doPTBEscaping) {
  Function<List<HasWord>, List<HasWord>> escaper;
  if (doPTBEscaping) {
    escaper = new PTBEscapingProcessor();
  } else {
    escaper = new NullEscaper();
  }
  return getSentencesFromXML(input, escaper, splitOnTag, sentenceDelimiter);
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
private List<List<? extends HasWord>> getSentencesFromText(Reader fileOrURL, boolean doPTBEscaping, String sentenceDelimiter, int tagDelimiter) {
  Function<List<HasWord>, List<HasWord>> escaper;
  if (doPTBEscaping) {
    escaper = new PTBEscapingProcessor();
  } else {
    escaper = new NullEscaper();
  }
  return getSentencesFromText(fileOrURL, escaper, sentenceDelimiter, tagDelimiter);
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
  * Returns the counter with keys modified according to function F. Eager evaluation.
  */
public static <T1,T2> Counter<T2> transform(Counter<T1> c, Function<T1,T2> f) {
   Counter<T2> c2 = new ClassicCounter<T2>();
   for(T1 key : c.keySet()) {
      c2.setCount(f.apply(key),c.getCount(key));
   }
   return c2;
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
public XMLBeginEndIterator(Reader in, String tagNameRegexp, Function<String,E> op, boolean keepInternalTags, boolean keepDelimitingTags) {
  this.tagNamePattern = Pattern.compile(tagNameRegexp);
  this.op = op;
  this.keepInternalTags = keepInternalTags;
  this.keepDelimitingTags = keepDelimitingTags;
  this.in = new BufferedReader(in);
  setNext();
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 * Returns a lexicalized Tree whose Labels are CategoryWordTag
 * instances, all corresponds to the input tree.
 */
public static Tree lexicalize(Tree t, HeadFinder hf) {
  Function<Tree,Tree> a = TreeFunctions.getLabeledTreeToCategoryWordTagTreeFunction();
  Tree t1 = a.apply(t);
  t1.percolateHeads(hf);
  return t1;
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
protected void tallyTreeIterator(Iterator<Tree> treeIterator, 
                                 Function<Tree, Tree> f, double weight) {
  while (treeIterator.hasNext()) {
    Tree tree = treeIterator.next();
    try {
      tree = f.apply(tree);
    } catch (Exception e) {
      if (op.testOptions.verbose) {
        e.printStackTrace();
      }
    }
    tallyTree(tree, weight);
  }
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
public LazyLoadTreesByParsing(String filename, String encoding, boolean tokenized, Function<Object, Tree> lp) {
  this.filename = filename;
  this.encoding = encoding;
  this.reader = null;
  this.tokenized = tokenized;
  this.lp = lp;
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
/**
 * Returns a lexicalized Tree whose Labels are CategoryWordTag
 * instances, all corresponds to the input tree.
 */
public static Tree lexicalize(Tree t, HeadFinder hf) {
  Function<Tree,Tree> a =
    TreeFunctions.getLabeledTreeToCategoryWordTagTreeFunction();
  Tree t1 = a.apply(t);
  t1.percolateHeads(hf);
  return t1;
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
private void removeBaselineFeature(String featName) {
  if(baselineFeatures.contains(featName)) {
    baselineFeatures.remove(featName);
    Pair<TregexPattern,Function<TregexMatcher,String>> p = annotationPatterns.get(featName);
    activeAnnotations.remove(p);
  }
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
private static Function<List<? extends HasWord>, Tree> loadParser(String parserFile, String parserOptions, boolean makeCopulaHead) {
  if (parserFile == null || "".equals(parserFile)) {
    parserFile = DEFAULT_PARSER_FILE;
    if (parserOptions == null) {
      parserOptions = "-retainTmpSubcategories";
    }
  }
  if (parserOptions == null) {
    parserOptions = "";
  }
  if (makeCopulaHead) {
    parserOptions = "-makeCopulaHead " + parserOptions;
  }
  parserOptions = parserOptions.trim();
  // Load parser by reflection, so that this class doesn't require parser
  // for runtime use
  // LexicalizedParser lp = LexicalizedParser.loadModel(parserFile);
  // For example, the tregex package uses TreePrint, which uses
  // GrammaticalStructure, which would then import the
  // LexicalizedParser.  The tagger can read trees, which means it
  // would depend on tregex and therefore depend on the parser.
  Function<List<? extends HasWord>, Tree> lp;
  try {
    Class<?>[] classes = new Class<?>[] { String.class, String[].class };
    Method method = Class.forName("edu.stanford.nlp.parser.lexparser.LexicalizedParser").getMethod("loadModel", classes);
    String[] opts = {};
    if (parserOptions.length() > 0) {
      opts = parserOptions.split(" +");
    }
    lp = (Function<List<? extends HasWord>,Tree>) method.invoke(null, parserFile, opts);
  } catch (Exception cnfe) {
    throw new RuntimeException(cnfe);
  }
  return lp;
}
 

import edu.stanford.nlp.util.Function; //导入依赖的package包/类
public XMLBeginEndIterator(Reader in, String tagNameRegexp, Function<String,E> op,
                           boolean keepInternalTags, boolean keepDelimitingTags, boolean countDepth) {
  this.tagNamePattern = Pattern.compile(tagNameRegexp);
  this.op = op;
  this.keepInternalTags = keepInternalTags;
  this.keepDelimitingTags = keepDelimitingTags;
  this.countDepth = countDepth;
  this.inputReader = new BufferedReader(in);
  setNext();
}