import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
private void flush(RepeatedRecordInfo info, List<Record> willReturn) {
  //(suppress all printing)
  if(info.suppressRecord){ return; }
  //(get time)
  int repeatedRecordCount = info.timesSeen - info.timesPrinted;
  if (repeatedRecordCount > 0) {
    //(send message record)
    //((add force tag))
    Object[] newTags = new Object[info.lastRecord.channels().length+1];
    System.arraycopy(info.lastRecord.channels(),0,newTags,1,info.lastRecord.channels().length);
    newTags[0] = Redwood.FORCE;
    //((create record))
    Record newRecord = new Record(
        repeatSemantics.message(repeatedRecordCount),
        newTags,
        info.lastRecord.depth,
        info.lastRecord.callingClass,
        info.lastRecord.callingMethod,
        info.lastRecord.timesstamp);
    //((pass record))
    willReturn.add(newRecord);
    info.timesSeen = 0;
    info.timesPrinted = 0;
  }
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
private boolean recordVerdict(Record r, boolean isRepeat, boolean shouldPrint, List<Record> willReturn){
  if(r.force()){
    flushParents(willReturn);
    if(isRepeat){ flush(current,willReturn); } //if not repeat, will flush below
    shouldPrint = true;
  }
  if(!isRepeat) {
    flush(current,willReturn);
    current.lastRecord = r;
  }
  if(shouldPrint){
    current.timeOfLastPrintedRecord = r.timesstamp;
    current.timesPrinted += 1;
  }
  current.timesSeen += 1;
  current.somethingPrinted = true;
  //(return)
  return shouldPrint;
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public List<Record> signalStartTrack(Record signal) {
  //(handle record)
  List<Record> willReturn = new ArrayList<Record>();
  boolean isPrinting = internalHandle(signal, willReturn);
  //(adjust state for track)
  if(!signal.force()){
    if(isPrinting){
      current.trackCountPending = PendingType.PRINTING;
      current.timesPrinted -= 1;
    }else{
      current.trackCountPending = PendingType.SEEN;
    }
    current.timesSeen -= 1;
  }
  //(push stack)
  stack.push(current);
  current = new RepeatedRecordInfo();
  if(!isPrinting){ current.suppressRecord = true; }
  return willReturn;
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public List<Record> signalEndTrack(int newDepth, long timeEnded) {
  List<Record> willReturn = new ArrayList<Record>();
  //(get state info)
  boolean trackWasNonempty = current.somethingPrinted;
  //(flush)
  flush(current,willReturn);
  current = stack.pop();
  //(update seen counts)
  if(trackWasNonempty){
    if(current.trackCountPending == PendingType.PRINTING){
      //((track was in fact printed))
      current.timesPrinted += 1;
    }
    if(current.trackCountPending != PendingType.NONE){
      //((track was in fact seen))
      current.timesSeen += 1;
    }
    //((track is nonempty))
    current.somethingPrinted = true;
  }
  //(update this track)
  current.trackCountPending = PendingType.NONE;
  return willReturn;
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
private void updateTracks(int untilDepth){
  while(!queuedTracks.isEmpty()){
    //(get record to update)
    Record signal = queuedTracks.removeFirst();
    if(signal.depth >= untilDepth){ queuedTracks.add(signal); return; }
    //(begin record message)
    StringBuilder b = new StringBuilder();
    if(missingOpenBracket){
      b.append("{\n");
    }
    //(write margin)
    for(int i=0; i<leftMargin; i++){
      b.append(" ");
    }
    //(write name)
    writeContent(signal.depth,signal.content,b);
    if(signal.content.toString().length() > 0){ b.append(" "); }
    //(print)
    print(null, this.style(new StringBuilder(), b.toString(), trackColor, trackStyle).toString() );
    this.missingOpenBracket = true;  //only set to false if actually updated track state
    //(update lines printed)
    if(info != null){
      info.numElementsPrinted += 1;
    }
  }
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public List<Record> signalStartTrack(Record signal) {
  //(queue track)
  this.queuedTracks.addLast(signal);
  //(push info)
  if(info != null){
    this.trackStack.push(info);
  }
  info = new TrackInfo(signal.content.toString(), signal.timesstamp);
  //(force print)
  if(signal.force()){
    updateTracks(signal.depth+1);
  }
  //(return)
  return EMPTY; //don't send extra records
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
private void flushParents(List<Record> willReturn){
  Stack<RepeatedRecordInfo> reverseStack = new Stack<RepeatedRecordInfo>();
    while(!stack.isEmpty()){
      reverseStack.push(stack.pop());
    }
    while(!reverseStack.isEmpty()){
      RepeatedRecordInfo info = reverseStack.pop();
      info.timesSeen -= 1;
      flush(info, willReturn);
      stack.push(info);
    }
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
private boolean internalHandle(Record record, List<Record> willReturn){
  // We are passing the record through a number of filters,
  // ordered by priority, to determine whether or not
  // to continue passing it on

  //--Special Cases
  //--Regular Cases
  //(ckeck squashing)
  if(this.current.suppressRecord){
    return recordVerdict(record, false, false, willReturn); //arg 2 is irrelevant here
  }
  //(check first record printed)
  if(this.current.lastRecord == null){
    return recordVerdict(record,false, true, willReturn);
  }
  //(check equality)
  if(this.repeatSemantics.equals(current.lastRecord,record)){
    //(check time)
    long currentTime = record.timesstamp;
    if(currentTime - this.current.timeOfLastPrintedRecord > this.repeatSemantics.maxWaitTimeInMillis()){
      return recordVerdict(record, true, true, willReturn);
    }
    //(check num printed)
    if(this.current.timesSeen < this.repeatSemantics.numToForcePrint()){
      return recordVerdict(record, true, true, willReturn);
    } else {
      return recordVerdict(record, true, false, willReturn);
    }
  } else {
    //(different record)
    return recordVerdict(record, false, true, willReturn);
  }
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
/** {@inheritDoc} */
public List<Record> handle(Record record) {
  List<Record> willReturn = new ArrayList<Record>();
  if(internalHandle(record, willReturn)){
    willReturn.add(record);
  }
  return willReturn;
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public List<Record> signalShutdown(){
  List<Record> willReturn = new ArrayList<Record>();
  flush(current,willReturn);
  return willReturn;
}
 

import edu.stanford.nlp.util.logging.Redwood.Record; //导入依赖的package包/类
public boolean equals(Record lastRecord, Record record) {
  return record.callingClass.equals(lastRecord.callingClass) &&
      record.callingMethod.equals(lastRecord.callingMethod) &&
      Arrays.equals(record.channels(), lastRecord.channels()) &&
      sameMessage(
        lastRecord.content == null ? "null" : lastRecord.content.toString(),
        record.content == null ? "null" : record.content.toString()
      );
}