import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * A main method for training and evaluating the postprocessor.
 * 
 * @param args
 */
public static void main(String[] args) {
  // Strips off hyphens
  Properties options = StringUtils.argsToProperties(args, optionArgDefs());
  if (options.containsKey("help") || args.length == 0) {
    System.err.println(usage(GermanPostprocessor.class.getName()));
    System.exit(-1);
  }

  int nThreads = PropertiesUtils.getInt(options, "nthreads", 1);
  GermanPreprocessor preProcessor = new GermanPreprocessor();
  GermanPostprocessor postProcessor = new GermanPostprocessor(options);
  
  CRFPostprocessor.setup(postProcessor, preProcessor, options);
  CRFPostprocessor.execute(nThreads, preProcessor, postProcessor);    
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * A main method for training and evaluating the postprocessor.
 * 
 * @param args
 */
public static void main(String[] args) {
  // Strips off hyphens
  Properties options = StringUtils.argsToProperties(args, optionArgDefs());
  if (options.containsKey("help") || args.length == 0) {
    System.err.println(usage(FrenchPostprocessor.class.getName()));
    System.exit(-1);
  }

  int nThreads = PropertiesUtils.getInt(options, "nthreads", 1);
  FrenchPreprocessor preProcessor = new FrenchPreprocessor();
  FrenchPostprocessor postProcessor = new FrenchPostprocessor(options);
  
  CRFPostprocessor.setup(postProcessor, preProcessor, options);
  CRFPostprocessor.execute(nThreads, preProcessor, postProcessor);    
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * A main method for training and evaluating the postprocessor.
 * 
 * @param args
 */
public static void main(String[] args) {
  // Strips off hyphens
  Properties options = StringUtils.argsToProperties(args, optionArgDefs());
  if (options.containsKey("help") || args.length == 0) {
    System.err.println(usage(EnglishPostprocessor.class.getName()));
    System.exit(-1);
  }

  int nThreads = PropertiesUtils.getInt(options, "nthreads", 1);
  EnglishPreprocessor preProcessor = new EnglishPreprocessor();
  EnglishPostprocessor postProcessor = new EnglishPostprocessor(options);
  
  CRFPostprocessor.setup(postProcessor, preProcessor, options);
  CRFPostprocessor.execute(nThreads, preProcessor, postProcessor);    
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * A main method for training and evaluating the postprocessor.
 * 
 * @param args
 */
public static void main(String[] args) {
  // Strips off hyphens
  Properties options = StringUtils.argsToProperties(args, optionArgDefs());
  if (options.containsKey("help") || args.length == 0) {
    System.err.println(usage(SpanishPostprocessor.class.getName()));
    System.exit(-1);
  }

  int nThreads = PropertiesUtils.getInt(options, "nthreads", 1);
  SpanishPreprocessor preProcessor = new SpanishPreprocessor();
  SpanishPostprocessor postProcessor = new SpanishPostprocessor(options);
  
  CRFPostprocessor.setup(postProcessor, preProcessor, options);
  CRFPostprocessor.execute(nThreads, preProcessor, postProcessor);    
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * Constructor.
 * 
 * @param args
 */
public TargetFunctionWordInsertion(String...args) {
  Properties options = FeatureUtils.argsToProperties(args);
  if (args.length < 2) {
    throw new RuntimeException("Must specify source and target unigram counts files");
  }
  System.err.println("Loading TargetFunctionWordInsertion template...");
  String sourceFilename = options.getProperty("sourceFile");
  String targetFilename = options.getProperty("targetFile");
  this.rankCutoff = PropertiesUtils.getInt(options, "rankCutoff", DEFAULT_RANK_CUTOFF);
  
  System.err.println("Source words:");
  sourceFunctionWordSet = loadCountsFile(sourceFilename);
  System.err.println("Target words:");
  targetFunctionWordSet = loadCountsFile(targetFilename);
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
public ArabicLexer(Reader r, LexedTokenFactory<?> tf, Properties props) {
  this(r);
  this.tokenFactory = tf;
  
  tokenizeNL = PropertiesUtils.getBool(props, "tokenizeNLs", false);
  useUTF8Ellipsis = PropertiesUtils.getBool(props, "useUTF8Ellipsis", false);
  invertible = PropertiesUtils.getBool(props, "invertible", false);
  normArDigits = PropertiesUtils.getBool(props, "normArDigits", false);
  normArPunc = PropertiesUtils.getBool(props, "normArPunc", false);
  normAlif = PropertiesUtils.getBool(props, "normAlif", false);
  normYa = PropertiesUtils.getBool(props, "normYa", false);
  removeDiacritics = PropertiesUtils.getBool(props, "removeDiacritics", false);
  removeTatweel = PropertiesUtils.getBool(props, "removeTatweel", false);
  removeQuranChars = PropertiesUtils.getBool(props, "removeQuranChars", false);
  removeProMarker = PropertiesUtils.getBool(props, "removeProMarker", false);
  removeSegMarker = PropertiesUtils.getBool(props, "removeSegMarker", false);
  removeMorphMarker = PropertiesUtils.getBool(props, "removeMorphMarker", false);
  atbEscaping = PropertiesUtils.getBool(props, "atbEscaping", false);

  setupNormalizationMap();
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
public ChineseSegmenterAnnotator(String name, Properties props) {
  String model = null;
  // Keep only the properties that apply to this annotator
  Properties modelProps = new Properties();
  for (String key : props.stringPropertyNames()) {
    if (key.startsWith(name + ".")) {
      // skip past name and the subsequent "."
      String modelKey = key.substring(name.length() + 1);
      if (modelKey.equals("model")) {
        model = props.getProperty(key);
      } else {
        modelProps.setProperty(modelKey, props.getProperty(key));
      }
    }
  }
  this.VERBOSE = PropertiesUtils.getBool(props, name + ".verbose", true);
  if (model == null) {
    throw new RuntimeException("Expected a property " + name + ".model");
  }
  loadModel(model, modelProps);
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
public ArabicSegmentorAnnotator(String name, Properties props) {
    // We are only interested in {name}.* properties
    String prefix = name + '.';
    String model = null;
    Properties segProps = new Properties();
    for (String key : props.stringPropertyNames()) {
        if (key.startsWith(prefix)) {
            // skip past name and the subsequent "."
            String modelKey = key.substring(prefix.length());
            if (modelKey.equals("model")) {
                model = props.getProperty(key);
            } else {
                segProps.setProperty(modelKey, props.getProperty(key));
            }
        }
    }
    this.VERBOSE = PropertiesUtils.getBool(props, name + ".verbose", true);
    init(model, segProps);

}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
public static void main (String[] args) {
    // Create the Stanford CoreNLP pipeline
    Properties props = PropertiesUtils.asProperties("annotators", "tokenize,ssplit,pos,lemma,depparse,natlog,openie",
            "parse.model", "edu/stanford/nlp/models/parser/nndep/english_SD.gz",
            "depparse.model", "edu/stanford/nlp/models/parser/nndep/english_SD.gz");
    StanfordCoreNLP pipeline = new StanfordCoreNLP(props);
    // Annotate an example document.
    String text = "I went into my bedroom and flipped the light switch. Oh, I see that the ceiling lamp is not turning on." +
            " It must be that the light bulb needs replacement. I go through my closet and find a new light bulb that will fit" +
            " this lamp and place it in my pocket. I also get my stepladder and place it under the lamp. I make sure the light" +
            " switch is in the off position. I climb up the ladder and unscrew the old light bulb. I place the old bulb in my " +
            "pocket and take out the new one. I then screw in the new bulb. I climb down the stepladder and place it back into " +
            "the closet. I then throw out the old bulb into the recycling bin. I go back to my bedroom and turn on the light switch." +
            " I am happy to see that there is again light in my room.";
    Annotation doc = new Annotation(text);
    pipeline.annotate(doc);
    // Loop over sentences in the document
    int sentNo = 0;
    for (CoreMap sentence : doc.get(CoreAnnotations.SentencesAnnotation.class)) {
        System.out.println("Sentence #" + ++sentNo + ": " + sentence.get(CoreAnnotations.TextAnnotation.class));
        // Get the OpenIE triples for the sentence
        Collection<RelationTriple> triples = sentence.get(NaturalLogicAnnotations.RelationTriplesAnnotation.class);
        // Print the triples
        for (RelationTriple triple : triples) {
            System.out.println(triple.confidence + "\t" + triple.subjectLemmaGloss() + "\t" + triple.relationLemmaGloss() + "\t" + triple.objectLemmaGloss());
        }
        System.out.println("\n");
    }

}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * Annotator to capture Multi-Word Expressions (MWE).
 * @param name
 *            annotator name
 * @param props
 *            the properties
 */
public JMWEAnnotator(String name, Properties props) {
    // set verbosity
    this.verbose = PropertiesUtils.getBool(props, "customAnnotatorClass.jmwe.verbose", false);
    // set underscoreSpaceReplacement
    if (!PropertiesUtils.hasProperty(props, "customAnnotatorClass.jmwe.underscoreReplacement")) {
        throw new RuntimeException("No customAnnotatorClass.jmwe.underscoreReplacement key in properties found");
    }
    underscoreSpaceReplacement = (String) props.get("customAnnotatorClass.jmwe.underscoreReplacement");
    if (underscoreSpaceReplacement.contains("_")) {
        throw new RuntimeException("The underscoreReplacement contains an underscore character");
    }
    // set index
    if (!PropertiesUtils.hasProperty(props, "customAnnotatorClass.jmwe.indexData")) {
        throw new RuntimeException("No customAnnotatorClass.jmwe.indexData key in properties found");
    }
    File indexFile = new File((String) props.get("customAnnotatorClass.jmwe.indexData"));
    if (!indexFile.exists()) {
        throw new RuntimeException("index file " + indexFile.getAbsoluteFile() + " does not exist");
    }

    this.index = new MWEIndex(indexFile);
    // set detector
    if (!PropertiesUtils.hasProperty(props, "customAnnotatorClass.jmwe.detector")) {
        throw new RuntimeException("No customAnnotatorClass.jmwe.detector key in properties found");
    }
    this.detectorName = (String) props.get("customAnnotatorClass.jmwe.detector");

    if (this.verbose) {
        System.out.println("verbose: " + this.verbose);
        System.out.println("underscoreReplacement: " + this.underscoreSpaceReplacement);
        System.out.println("indexData: " + this.index);
        System.out.println("detectorName: " + this.detectorName);
    }
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * 
 * @param args
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
  if (args.length < 1) {
    System.err.print(usage());
    System.exit(-1);
  }

  Properties options = StringUtils.argsToProperties(args, argDefs());
  final double scale = PropertiesUtils.getDouble(options, "s", DEFAULT_SCALE);
  final String orientation = options.getProperty("o", "utility");
  final boolean risk = "risk".equals(orientation);
  final String metricName = options.getProperty("m", DEFAULT_METRIC);

  final String filename = options.getProperty("");
  BasicNBestList nbestlists = new BasicNBestList(filename);
  MulticoreWrapper<List<BasicNBestEntry>, List<Pair<Double, String>>> wrapper = 
    new MulticoreWrapper<List<BasicNBestEntry>, List<Pair<Double, String>>>(0, new Processor(metricName, risk, scale), true);
  for (List<BasicNBestEntry> nbestlist : nbestlists) {
    wrapper.put(nbestlist);
    while (wrapper.peek()) {
      DumpRescored(wrapper.poll());
    }
  }
  wrapper.join();
  while (wrapper.peek()) {
    DumpRescored(wrapper.poll());
  }
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
public static void main(String[] args) {

    Properties options = StringUtils.argsToProperties(args, optionArgDefs());
    String annotations = PropertiesUtils.get(options, "annotations", null, String.class);
    
    boolean changepreps = PropertiesUtils.getBool(options, "changepreps", false);
    
    int sentenceCount = CoreNLPCache.loadSerialized(annotations);
   
    
    CoreMap sentence;
    for (int i = 0; i < sentenceCount; i++) {
      try {  
        sentence = CoreNLPCache.get(i);
        if (sentence == null) {
          System.out.println();
          System.err.println("Empty sentence #" + i);
          continue;
        }
        printDependencies(sentence, changepreps);
        //System.err.println("---------------------------");
      } catch (Exception e) {
        System.err.println("SourceSentence #" + i);
        e.printStackTrace();
        return;
      }
    }
  }
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * 
 * @param args
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
  if (args.length < 1) {
    System.err.print(usage());
    System.exit(-1);
  }
  
  Properties options = StringUtils.argsToProperties(args, argDefs());
  int ngramOrder = PropertiesUtils.getInt(options, "order", BLEUMetric.DEFAULT_MAX_NGRAM_ORDER);
  boolean disableTokenization = PropertiesUtils.getBool(options, "no-nist", false);
  String metric = options.getProperty("metric", "bleu");

  String[] refs = options.getProperty("").split("\\s+");
  List<List<Sequence<IString>>> referencesList = MetricUtils.readReferences(refs, ! disableTokenization);
  System.err.printf("Metric: %s with %d references%n", metric, referencesList.get(0).size());
  
  LineNumberReader reader = new LineNumberReader(new InputStreamReader(
      System.in));
  int sourceInputId = 0;
  for (String line; (line = reader.readLine()) != null; ++sourceInputId) {
    line = disableTokenization ? line : NISTTokenizer.tokenize(line);
    Sequence<IString> translation = IStrings.tokenize(line);
    double score = getScore(translation, referencesList.get(sourceInputId), ngramOrder, metric);
    System.out.printf("%.4f%n", score);
  }
  System.err.printf("Scored %d input segments%n", sourceInputId);
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * Constructor called by Phrasal when NGramLanguageModelFeaturizer appears in
 * <code>Phrasal.LANGUAGE_MODEL_OPT</code>.
 * 
 * The first argument is always the language model filename and the second
 * argument is always the feature name.
 * 
 * Additional arguments are named parameters.
 */
public NGramLanguageModelFeaturizer(String...args) throws IOException {
  if (args.length < 2) {
    throw new RuntimeException(
        "At least two arguments are needed: LM file name and LM feature name");
  }
  // Load the LM
  this.lm = LanguageModelFactory.load(args[0]);
  this.startToken = lm.getStartToken();
  this.endToken = lm.getEndToken();

  // Set the feature name
  this.featureName = args[1];

  // Named parameters
  Properties options = FeatureUtils.argsToProperties(args);
  this.isClassBased = PropertiesUtils.getBool(options, "classBased", false);
  if (isClassBased && options.containsKey("classMap")) {
    // A local class map that differs from the one specified by Phrasal.TARGET_CLASS_MAP
    this.targetClassMap = new LocalTargetMap();
    this.targetClassMap.load(options.getProperty("classMap"));
  } else if (isClassBased) {
    this.targetClassMap = TargetClassMap.getInstance();
  } else {
    this.targetClassMap = null;
  }    
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * Constructor for reflection loading discriminative lexicalized reordering.
 * 
 * @param args
 */
public LexicalReorderingFeaturizer(String...args) {
  Properties options = FeatureUtils.argsToProperties(args);
  this.dynamic = PropertiesUtils.getBool(options, "dynamic", false);
  if (dynamic) {
    this.discriminativeSet = null;
    this.mlrt = null;
    this.featureTags = Arrays.stream(LexicalReorderingTable.msdBidirectionalPositionMapping).map(m -> 
    String.format("%s:%s", FEATURE_PREFIX, m)).toArray(String[]::new);
    this.useAlignmentConstellations = false;
    this.useClasses = false;
    this.countFeatureIndex = -1;
    this.lexicalCutoff = 0;

  } else {
    this.discriminativeSet = new ArrayList<>(Arrays.asList(LexicalReorderingTable.ReorderingTypes.values()));
    this.useAlignmentConstellations = options.containsKey("conditionOnConstellations");
    this.countFeatureIndex = PropertiesUtils.getInt(options, "countFeatureIndex", -1);
    // Which reordering classes to extract
    if (options.containsKey("classes")) {
      String[] typeStrings = options.getProperty("classes").split("-");
      discriminativeSet = new ArrayList<>();
      for (String type : typeStrings) {
        discriminativeSet.add(LexicalReorderingTable.ReorderingTypes.valueOf(type));
      }
    }
    // Use class-based feature representations
    this.useClasses = options.containsKey("useClasses");
    if (useClasses) {
      sourceMap = SourceClassMap.getInstance();
      targetMap = TargetClassMap.getInstance();
    }
    this.mlrt = null;
    this.featureTags = null;
    this.lexicalCutoff = PropertiesUtils.getInt(options, "lexicalCutoff", 0);
  }
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
/**
 * Constructor for reflection loading.
 * 
 * @param args
 */
public RuleIndicator(String... args) {
  Properties options = FeatureUtils.argsToProperties(args);
  this.addLexicalizedRule = options.containsKey("addLexicalized");
  this.addClassBasedRule = options.containsKey("addClassBased");

  this.countFeatureIndex = PropertiesUtils.getInt(options, "countFeatureIndex", -1);
  if (addClassBasedRule) {
    sourceMap = SourceClassMap.getInstance();
    targetMap = TargetClassMap.getInstance();
  }
  this.lexicalCutoff = PropertiesUtils.getInt(options, "lexicalCutoff", 0);
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
private static boolean validateCommandLine(String[] args) {
  // Command line parsing
  Properties options = StringUtils.argsToProperties(args, argDefs());

  VERBOSE = options.containsKey("v");
  SRC_FILE = options.getProperty("s", null);
  OPTS_FILE = options.getProperty("o", null);
  XSD_FILE = options.getProperty("x", null);
  FIRST_ID = PropertiesUtils.getInt(options, "f", Integer.MIN_VALUE);
  LAST_ID = PropertiesUtils.getInt(options,"l",Integer.MAX_VALUE);

  return true;
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
public Tokenizer<T> getTokenizer(Reader r, String extraOptions) {
  Properties prop = StringUtils.stringToProperties(extraOptions);
  boolean tokenizeNewlines =
    PropertiesUtils.getBool(prop, "tokenizeNLs", this.tokenizeNLs);

  return new WhitespaceTokenizer<T>(factory, r, tokenizeNewlines);
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
public Tokenizer<HasWord> getTokenizer(Reader r, String extraOptions) {
  boolean tokenizeNewlines = this.tokenizeNLs;
  if (extraOptions != null) {
    Properties prop = StringUtils.stringToProperties(extraOptions);
    tokenizeNewlines = PropertiesUtils.getBool(prop, "tokenizeNLs", this.tokenizeNLs);
  }

  return new WordSegmentingTokenizer(segmenter, WhitespaceTokenizer.newCoreLabelWhitespaceTokenizer(r, tokenizeNewlines));
}
 

import edu.stanford.nlp.util.PropertiesUtils; //导入依赖的package包/类
public POSTaggerAnnotator(String annotatorName, Properties props) {
  String posLoc = props.getProperty(annotatorName + ".model");
  if (posLoc == null) {
    posLoc = DefaultPaths.DEFAULT_POS_MODEL;
  }
  boolean verbose = PropertiesUtils.getBool(props, annotatorName + ".verbose", false);
  this.pos = loadModel(posLoc, verbose);
  this.maxSentenceLength = PropertiesUtils.getInt(props, annotatorName + ".maxlen", Integer.MAX_VALUE);
  this.nThreads = PropertiesUtils.getInt(props, annotatorName + ".nthreads", PropertiesUtils.getInt(props, "nthreads", 1));
}