import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
@Override public Set<Class<? extends CoreAnnotation>> requirementsSatisfied() {
    return new HashSet<>(Arrays.asList(
            CoreAnnotations.TextAnnotation.class,
            CoreAnnotations.TokensAnnotation.class,
            CoreAnnotations.CharacterOffsetBeginAnnotation.class,
            CoreAnnotations.CharacterOffsetEndAnnotation.class,
            CoreAnnotations.BeforeAnnotation.class,
            CoreAnnotations.AfterAnnotation.class,
            CoreAnnotations.TokenBeginAnnotation.class,
            CoreAnnotations.TokenEndAnnotation.class,
            CoreAnnotations.PositionAnnotation.class,
            CoreAnnotations.IndexAnnotation.class,
            CoreAnnotations.OriginalTextAnnotation.class,
            CoreAnnotations.ValueAnnotation.class,
            CoreAnnotations.SentencesAnnotation.class,
            CoreAnnotations.SentenceIndexAnnotation.class
    ));
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Set<Class<? extends CoreAnnotation>> requires() {
    Set<Class<? extends CoreAnnotation>> requirements = new HashSet<>(Arrays.asList(
            CoreAnnotations.TextAnnotation.class,
            CoreAnnotations.TokensAnnotation.class,
            CoreAnnotations.IndexAnnotation.class,
            CoreAnnotations.SentencesAnnotation.class,
            CoreAnnotations.SentenceIndexAnnotation.class,
            CoreAnnotations.PartOfSpeechAnnotation.class,
            CoreAnnotations.LemmaAnnotation.class,
            SemanticGraphCoreAnnotations.BasicDependenciesAnnotation.class,
            SemanticGraphCoreAnnotations.CollapsedDependenciesAnnotation.class,
            SemanticGraphCoreAnnotations.CollapsedCCProcessedDependenciesAnnotation.class,
            CoreAnnotations.OriginalTextAnnotation.class
    ));
    return Collections.unmodifiableSet(requirements);
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
@Override
/**
 * Using the same requirements as the CoreNLP NERCombinerAnnotator
 */
public Set<Class<? extends CoreAnnotation>> requires() {
    return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(
            CoreAnnotations.TextAnnotation.class,
            CoreAnnotations.TokensAnnotation.class,
            CoreAnnotations.SentencesAnnotation.class,
            CoreAnnotations.CharacterOffsetBeginAnnotation.class,
            CoreAnnotations.CharacterOffsetEndAnnotation.class,
            CoreAnnotations.PartOfSpeechAnnotation.class,
            CoreAnnotations.LemmaAnnotation.class,
            CoreAnnotations.BeforeAnnotation.class,
            CoreAnnotations.AfterAnnotation.class,
            CoreAnnotations.TokenBeginAnnotation.class,
            CoreAnnotations.TokenEndAnnotation.class,
            CoreAnnotations.IndexAnnotation.class,
            CoreAnnotations.OriginalTextAnnotation.class,
            CoreAnnotations.SentenceIndexAnnotation.class
        )));
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Finds all arcs between this node and <code>destNode</code>,
 * and returns the <code>Set</code> of <code>Object</code>s which
 * label those arcs.  If no such arcs exist, returns an empty
 * <code>Set</code>.
 *
 * @param destNode the destination node
 * @return the <code>Set</code> of <code>Object</code>s which
 *         label arcs between this node and <code>destNode</code>
 */
public Set<Class<? extends GrammaticalRelationAnnotation>> arcLabelsToNode(TreeGraphNode destNode) {
  Set<Class<? extends GrammaticalRelationAnnotation>> arcLabels = Generics.newHashSet();
  CyclicCoreLabel cl = label();
  for (Iterator<Class<?>> it = cl.keySet().iterator(); it.hasNext();) {
    Class<? extends CoreAnnotation> key = (Class<? extends CoreAnnotation>) it.next();//javac doesn't compile properly if generics are fully specified (but eclipse does...)
    Object val = cl.get(key);
    if (val != null && val instanceof Set) {
      if (((Set) val).contains(destNode)) {
        if (key != null) {
          arcLabels.add((Class<? extends GrammaticalRelationAnnotation>) key);
        }
      }
    }
  }
  return arcLabels;
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Returns all the dependencies of a certain node.
 *
 * @param node The node to return dependents for
 * @return map of dependencies
 */
private static Map<Class<? extends CoreAnnotation>, Set<TreeGraphNode>> getAllDependents(TreeGraphNode node) {
  Map<Class<? extends CoreAnnotation>, Set<TreeGraphNode>> newMap = Generics.newHashMap();

  for (Class<?> o : node.label.keySet()) {
    try {
      // The line below will exception unless it's a GrammaticalRelationAnnotation,
      // so the effect is that only the GrammaticalRelationAnnotation things get put into newMap
      o.asSubclass(GrammaticalRelationAnnotation.class);
      newMap.put((Class<? extends CoreAnnotation>) o, (Set<TreeGraphNode>) node.label.get((Class<? extends CoreAnnotation>) o));//javac doesn't compile properly if generics are fully specified (but eclipse does...)
    } catch (Exception e) {
      // ignore a non-GrammaticalRelationAnnotation element
    }
  }
  return newMap;
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Returns the set of tasks which this annotator requires in order
 * to perform.  For example, the POS annotator will return
 * "tokenize", "ssplit".
 */
@Override
public Set<Class<? extends CoreAnnotation>> requires() {
    return Collections.unmodifiableSet(new ArraySet<>(Arrays.asList(
            CoreAnnotations.PartOfSpeechAnnotation.class,
            DigiMorphAnnotations.MorphoAnnotation.class,
            CoreAnnotations.TokensAnnotation.class,
            CoreAnnotations.SentencesAnnotation.class
    )));
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Returns the set of tasks which this annotator requires in order
 * to perform.  For example, the POS annotator will return
 * "tokenize", "ssplit".
 */
@Override public Set<Class<? extends CoreAnnotation>> requires() {
    return Collections.unmodifiableSet(new ArraySet<>(Arrays.asList(
            CoreAnnotations.LemmaAnnotation.class,
            DigiMorphAnnotations.MorphoAnnotation.class
    )));
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Returns the set of tasks which this annotator requires in order
 * to perform.  For example, the POS annotator will return
 * "tokenize", "ssplit".
 */
@Override public Set<Class<? extends CoreAnnotation>> requires() {
    return Collections.unmodifiableSet(new ArraySet<>(Arrays.asList(
            CoreAnnotations.TokensAnnotation.class,
            CoreAnnotations.SentencesAnnotation.class
    )));
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Returns the set of tasks which this annotator requires in order
 * to perform.  For example, the POS annotator will return
 * "tokenize", "ssplit".
 */
@Override public Set<Class<? extends CoreAnnotation>> requires() {
    return Collections.unmodifiableSet(new ArraySet<>(Arrays.asList(
            CoreAnnotations.PartOfSpeechAnnotation.class,
            CoreAnnotations.LemmaAnnotation.class,
            CoreAnnotations.TokensAnnotation.class,
            CoreAnnotations.SentencesAnnotation.class
    )));
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Returns the set of tasks which this annotator requires in order
 * to perform.  For example, the POS annotator will return
 * "tokenize", "ssplit".
 */
@Override public Set<Class<? extends CoreAnnotation>> requires() {
    return Collections.unmodifiableSet(new ArraySet<>(Arrays.asList(
            CoreAnnotations.PartOfSpeechAnnotation.class,
            CoreAnnotations.TokensAnnotation.class,
            CoreAnnotations.LemmaAnnotation.class,
            CoreAnnotations.SentencesAnnotation.class
    )));
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
@Override
public Set<Class<? extends CoreAnnotation>> requires() {
    return Collections.unmodifiableSet(new ArraySet<>(Arrays.asList(
            CoreAnnotations.PartOfSpeechAnnotation.class,
            CoreAnnotations.TokensAnnotation.class
    )));
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Set<Class<? extends CoreAnnotation>> requirementsSatisfied() {
    Set<Class<? extends CoreAnnotation>> requirements = new HashSet<>(Arrays.asList(
            CoreAnnotations.MentionsAnnotation.class,
            CoreAnnotations.KBPTriplesAnnotation.class
    ));
    return Collections.unmodifiableSet(requirements);
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/** Look through the tree t and adds to the List basicDep dependencies
 *  which aren't in it but which satisfy the filter f.
 *
 * @param t The tree to examine (not changed)
 * @param basicDep The list of dependencies which may be augmented
 * @param f Additional dependencies are added only if they pass this filter
 */
private static void getDep(TreeGraphNode t, List<TypedDependency> basicDep,
                           Filter<TypedDependency> f) {
  if (t.numChildren() > 0) {          // don't do leaves
    Map<Class<? extends CoreAnnotation>, Set<TreeGraphNode>> depMap = getAllDependents(t);
    for (Class<? extends CoreAnnotation> depName : depMap.keySet()) {
      for (TreeGraphNode depNode : depMap.get(depName)) {
        TreeGraphNode gov = t.headWordNode();
        TreeGraphNode dep = depNode.headWordNode();
        if (gov != dep) {
          List<GrammaticalRelation> rels = getListGrammaticalRelation(t, depNode);
          if (!rels.isEmpty()) {
            for (GrammaticalRelation rel : rels) {
              TypedDependency newDep = new TypedDependency(rel, gov, dep);
              if (!basicDep.contains(newDep) && f.accept(newDep)) {
                newDep.setExtra();
                basicDep.add(newDep);
              }
            }
          }
        }
      }
    }
    // now recurse into children
    for (Tree kid : t.children()) {
      getDep((TreeGraphNode) kid, basicDep, f);
    }
  }
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
public Counter<List<IN>> classifyKBest(List<IN> doc, Class<? extends CoreAnnotation<String>> answerField, int k) {

    if (doc.isEmpty()) {
      return new ClassicCounter<List<IN>>();
    }

    // TODO get rid of ObjectBankWrapper
    // i'm sorry that this is so hideous - JRF
    ObjectBankWrapper<IN> obw = new ObjectBankWrapper<IN>(flags, null, knownLCWords);
    doc = obw.processDocument(doc);

    SequenceModel model = getSequenceModel(doc);

    KBestSequenceFinder tagInference = new KBestSequenceFinder();
    Counter<int[]> bestSequences = tagInference.kBestSequences(model, k);

    Counter<List<IN>> kBest = new ClassicCounter<List<IN>>();

    for (int[] seq : bestSequences.keySet()) {
      List<IN> kth = new ArrayList<IN>();
      int pos = model.leftWindow();
      for (IN fi : doc) {
        IN newFL = tokenFactory.makeToken(fi);
        String guess = classIndex.get(seq[pos]);
        fi.remove(CoreAnnotations.AnswerAnnotation.class); // because fake answers will get
                                           // added during testing
        newFL.set(answerField, guess);
        pos++;
        kth.add(newFL);
      }
      kBest.setCount(kth, bestSequences.getCount(seq));
    }

    return kBest;
  }
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
public DFSA<String, Integer> getViterbiSearchGraph(List<IN> doc, Class<? extends CoreAnnotation<String>> answerField) {
  if (doc.isEmpty()) {
    return new DFSA<String, Integer>(null);
  }
  // TODO get rid of objectbankwrapper
  ObjectBankWrapper<IN> obw = new ObjectBankWrapper<IN>(flags, null, knownLCWords);
  doc = obw.processDocument(doc);
  SequenceModel model = getSequenceModel(doc);
  return ViterbiSearchGraphBuilder.getGraph(model, classIndex);
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
private static void addLemma(Morphology morpha,
                      Class<? extends CoreAnnotation<String>> ann,
                      CoreMap map, String word, String tag) {
  if (tag.length() > 0) {
    String phrasalVerb = phrasalVerb(morpha, word, tag);
    if (phrasalVerb == null) {
      map.set(ann, morpha.lemma(word, tag));
    } else {
      map.set(ann, phrasalVerb);
    }
  } else {
    map.set(ann, morpha.stem(word));
  }
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/** Look through the tree t and adds to the List basicDep dependencies
 *  which aren't in it but which satisfy the filter f.
 *
 * @param t The tree to examine (not changed)
 * @param basicDep The list of dependencies which may be augmented
 * @param f Additional dependencies are added only if they pass this filter
 */
private static void getDep(TreeGraphNode t, List<TypedDependency> basicDep,
                           Filter<TypedDependency> f) {
  if (t.isPhrasal()) {          // don't do leaves of POS tags (chris changed this from numChildren > 0 in 2010)
    Map<Class<? extends CoreAnnotation>, Set<TreeGraphNode>> depMap = getAllDependents(t);
    for (Class<? extends CoreAnnotation> depName : depMap.keySet()) {
      for (TreeGraphNode depNode : depMap.get(depName)) {
        TreeGraphNode gov = t.headWordNode();
        TreeGraphNode dep = depNode.headWordNode();
        if (gov != dep) {
          List<GrammaticalRelation> rels = getListGrammaticalRelation(t, depNode);
          if (!rels.isEmpty()) {
            for (GrammaticalRelation rel : rels) {
              TypedDependency newDep = new TypedDependency(rel, gov, dep);
              if (!basicDep.contains(newDep) && f.accept(newDep)) {
                newDep.setExtra();
                basicDep.add(newDep);
              }
            }
          }
        }
      }
    }
    // now recurse into children
    for (Tree kid : t.children()) {
      getDep((TreeGraphNode) kid, basicDep, f);
    }
  }
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Returns all the dependencies of a certain node.
 *
 * @param node The node to return dependents for
 * @return map of dependencies
 */
private static Map<Class<? extends CoreAnnotation>, Set<TreeGraphNode>> getAllDependents(TreeGraphNode node) {
  Map<Class<? extends CoreAnnotation>, Set<TreeGraphNode>> newMap = Generics.newHashMap();

  for (Class<?> o : node.label.keySet()) {
    if (GrammaticalRelationAnnotation.class.isAssignableFrom(o)) {
      // ignore a non-GrammaticalRelationAnnotation element
      newMap.put((Class<? extends CoreAnnotation>) o, (Set<TreeGraphNode>) node.label.get((Class<? extends CoreAnnotation>) o));//javac doesn't compile properly if generics are fully specified (but eclipse does...)
    }
  }
  return newMap;
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
/**
 * Returns a set of requirements for which tasks this annotator can
 * provide.  For example, the POS annotator will return "pos".
 */
@Override
public Set<Class<? extends CoreAnnotation>> requirementsSatisfied() {
    return Collections.singleton(CoreAnnotations.LemmaAnnotation.class);
}
 

import edu.stanford.nlp.ling.CoreAnnotation; //导入依赖的package包/类
@Override public Set<Class<? extends CoreAnnotation>> requires() {
    return Collections.emptySet();
}