Java Redwood.startTrack方法代码示例

import edu.stanford.nlp.util.logging.Redwood; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
@SuppressWarnings("unchecked")
public void prettyLog(RedwoodChannels channels, String description) {
  Redwood.startTrack(description);

  // sort keys by class name
  List<Class> sortedKeys = new ArrayList<Class>(this.keySet());
  Collections.sort(sortedKeys,
      new Comparator<Class>(){
    @Override
    public int compare(Class a, Class b) {
      return a.getCanonicalName().compareTo(b.getCanonicalName());
    }
  });

  // log key/value pairs
  for (Class key : sortedKeys) {
    String keyName = key.getCanonicalName().replace("class ", "");
    Object value = this.get(key);
    if (PrettyLogger.dispatchable(value)) {
      PrettyLogger.log(channels, keyName, value);
    } else {
      channels.logf("%s = %s", keyName, value);
    }
  }
  Redwood.endTrack(description);
}
 

import edu.stanford.nlp.util.logging.Redwood; //导入方法依赖的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
 * @param callback
 *          A function to be called when an annotation finishes. The return value of the callback is ignored.
 */
public void annotate(final Iterable<Annotation> annotations, int numThreads, final Function<Annotation, Object> callback) {
  // case: single thread (no point in spawning threads)
  if (numThreads == 1) {
    for (Annotation ann : annotations) {
      annotate(ann);
      callback.apply(ann);
    }
  }
  // Java's equivalent to ".map{ lambda(annotation) => annotate(annotation) }
  Iterable<Runnable> threads = new Iterable<Runnable>() {
    @Override
    public Iterator<Runnable> iterator() {
      final Iterator<Annotation> iter = annotations.iterator();
      return new Iterator<Runnable>() {
        @Override
        public boolean hasNext() {
          return iter.hasNext();
        }

        @Override
        public Runnable next() {
          if (!iter.hasNext()) {
            throw new NoSuchElementException();
          }
          final Annotation input = iter.next();
          return new Runnable() {
            @Override
            public void run() {
              // (logging)
              String beginningOfDocument = input.toString().substring(0, Math.min(50, input.toString().length()));
              Redwood.startTrack("Annotating \"" + beginningOfDocument + "...\"");
              // (annotate)
              annotate(input);
              // (callback)
              callback.apply(input);
              // (logging again)
              Redwood.endTrack("Annotating \"" + beginningOfDocument + "...\"");
            }
          };
        }

        @Override
        public void remove() {
          iter.remove();
        }
      };
    }
  };
  // Thread
  Redwood.Util.threadAndRun(this.getClass().getSimpleName(), threads, numThreads);
}
 

import edu.stanford.nlp.util.logging.Redwood; //导入方法依赖的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
* @param callback A function to be called when an annotation finishes.
*                 The return value of the callback is ignored.
 */
public void annotate(final Iterable<Annotation> annotations, int numThreads, final Function<Annotation,Object> callback){
  // case: single thread (no point in spawning threads)
  if(numThreads == 1){
    for(Annotation ann : annotations){
      annotate(ann);
      callback.apply(ann);
    }
  }
  // Java's equivalent to ".map{ lambda(annotation) => annotate(annotation) }
  Iterable<Runnable> threads = new Iterable<Runnable>(){
    public Iterator<Runnable> iterator() {
      final Iterator<Annotation> iter = annotations.iterator();
      return new Iterator<Runnable>(){
        public boolean hasNext() {
          return iter.hasNext();
        }
        public Runnable next() {
          final Annotation input = iter.next();
          return new Runnable(){
            public void run(){
              //Jesus Christ, finally the body of the code
              //(logging)
              String beginningOfDocument = input.toString().substring(0,Math.min(50,input.toString().length()));
              Redwood.startTrack("Annotating \"" + beginningOfDocument + "...\"");
              //(annotate)
              annotate(input);
              //(callback)
              callback.apply(input);
              //(logging again)
              Redwood.endTrack("Annotating \"" + beginningOfDocument + "...\"");
            }
          };
        }
        public void remove() {
          iter.remove();
        }
      };
    }
  };
  // Thread
  Redwood.Util.threadAndRun(this.getClass().getSimpleName(), threads, numThreads );
}