How to use org.gridkit.jvmtool.codec.stacktrace

public void loadFrom(ThreadSnapshotEvent event) {
  copyCommonEventFrom(event);
  threadId(event.threadId());
  threadName(event.threadName());
  threadState(event.threadState());
  stackTrace(event.stackTrace());
}

  @Override
  public Event morph(Event event) {
    if (event instanceof ThreadTraceEvent && !(event instanceof ThreadSnapshotEvent)) {
      pojo.loadFromRawEvent((ThreadTraceEvent) event);
      return pojo;
    }
    else {
      return event;
    }
  }
}

  @Override
  public ThreadSnapshotEvent morph(ThreadSnapshotEvent event) {
    snap.loadFrom(event);
    snap.stackTrace(event.stackTrace().fragment(0, trimPoint));
    return snap;
  }
}    

public void loadFrom(ThreadSnapshot event) {
  if (event instanceof ThreadSnapshotEvent) {
    loadFrom((ThreadSnapshotEvent)event);
  }
  else {
    timestamp(event.timestamp());
    threadId(event.threadId());
    threadName(event.threadName());
    threadState(event.threadState());
    counters().clear();;
    counters().setAll(event.counters());
    stackTrace(event.stackTrace());
    if (event instanceof TaggedEvent) {
      tags().clear();
      tags().putAll(((TaggedEvent) event).tags());
    }
  }
}

public void loadFromRawEvent(ThreadTraceEvent event) {
  threadId(-1);
  threadName(null);
  threadState(null);
  CommonEvent cevent = (CommonEvent)event;
  copyCommonEventFrom(cevent);
  if (cevent.counters().getValue(JvmEvents.THREAD_ID) >= 0) {
    threadId(cevent.counters().getValue(JvmEvents.THREAD_ID));
  }
  threadName(cevent.tags().firstTagFor(JvmEvents.THREAD_NAME));
  threadState(state(cevent.tags().firstTagFor(JvmEvents.THREAD_STATE)));
  stackTrace(event.stackTrace());
}

  private void copyToBuf(ThreadSnapshotEvent event) {
    eventBuf.loadFrom(event);
//        eventBuf.tags().put(JvmEvents.JVM_EVENT_KEY, JvmEvents.EVENT_THREAD_SNAPSHOT);
    if (event.threadId() >= 0) {
      eventBuf.counters().set(JvmEvents.THREAD_ID, event.threadId());
    }
    if (event.threadName() != null) {
      eventBuf.tags().remove(JvmEvents.THREAD_NAME);
      eventBuf.tags().put(JvmEvents.THREAD_NAME, event.threadName());
    }
    if (event.threadState() != null) {
      eventBuf.tags().remove(JvmEvents.THREAD_STATE);
      eventBuf.tags().put(JvmEvents.THREAD_STATE, event.threadState().toString());
    }
  }

  public void format(StringBuilder sb, ThreadSnapshotEvent e) {
    String timestamp = fmt.format(e.timestamp());
    sb
      .append("Thread [")
      .append(e.threadId())
      .append("] ");
    
    if (e.threadState() != null) {
      sb.append(e.threadState()).append(' ');
    }
    
    sb.append("at ").append(timestamp);
    
    if (e.threadName() != null) {
      sb.append(" - ").append(e.threadName());
    }
    sb.append("\n");
    
    StackFrameList trace = e.stackTrace();
    for(StackFrame frame: trace) {
      sb.append(frame).append("\n");
    }
  }
}

public void feed(Iterable<ThreadSnapshotEvent> events) {
  for(ThreadSnapshotEvent e: events) {
    if (e.stackTrace() != null && e.stackTrace().depth() > 0) {
      String threadName = String.valueOf(e.threadName());
      
      ThreadDump dump = thread(threadName);
      
      int[] trace = intern(e);
      dump.count(trace);
    }
  }
}

  private int[] intern(ThreadSnapshotEvent e) {
    StackFrameList trace = e.stackTrace();
    int[] r = new int[trace.depth() + 1];
    for(int i = 0; i != trace.depth(); ++i) {
      int fp = trace.depth() - 1 - i;
      r[i] = intern(formater.toString(trace.frameAt(fp)));
    }
    
    if (e.threadState() == null) {
//            r = Arrays.copyOf(r, r.length - 1);
      r[r.length - 1] = intern("(???)");
    }
    else {
      r[r.length - 1] = intern(e.threadState());
    }
    
    return r;
  }

  @Override
  public ThreadSnapshotEvent morph(ThreadSnapshotEvent event) {
    if (event.stackTrace() != null && !event.stackTrace().isEmpty()) {
      ++traceCounter;
      return event;
    }
    else {
      return null;
    }
  }                    
}));

  protected boolean evaluate(ThreadSnapshotEvent event) {
    if (event.threadName() != null) {
      matcher.reset(event.threadName());
      return matcher.matches();
    }
    else {
      return false;
    }
  }
}

@Override
public State getThreadState() {
  return events.peekNext().threadState();
}

  @Override
  public ThreadSnapshotEvent morph(ThreadSnapshotEvent event) {
    return checker.evaluate(event.timestamp()) ? event : null;
  }
}

@Override
public long getThreadId() {
  return events.peekNext().threadId();
}

@Override
public CounterCollection getCounters() {
  return events.peekNext().counters();
}

 public static EventReader<Event> createEventReader(byte[] magic, InputStream is) throws IOException {
   if (Arrays.equals(magic, StackTraceCodec.MAGIC)) {
     StackTraceReader lreader = new StackTraceReaderV1(is);
     EventReader<Event> reader = new LegacyThreadEventReader(lreader);
     return reader;
   }
   if (Arrays.equals(magic, StackTraceCodec.MAGIC2)) {
     StackTraceReader lreader = new StackTraceReaderV2(is);
     EventReader<Event> reader = new LegacyThreadEventReader(lreader);
     return reader;
   }
   // MAGIC3 is not used
   else if (Arrays.equals(magic, StackTraceCodec.MAGIC4)) {
     EventReader<Event> reader = new StackTraceEventReaderV4(is).morph(new ThreadSnapshotExpander());
     return reader;
   }
   else {
     throw new IOException("Unknown magic '" + new String(magic) + "'");
   }
 }
}

@Override
public StackFrameList getStackTrace() {
  return events.peekNext().stackTrace();
}

@Override
public String getThreadName() {
  return events.peekNext().threadName();
}

@Override
public long getTimestamp() {
  return events.peekNext().timestamp();
}

@Override
public StackTraceElement[] getTrace() {
  StackFrameList list = events.peekNext().stackTrace();
  if (list == null) {
    return null;
  }
  else {
    StackTraceElement[] strace = new StackTraceElement[list.depth()];
    for(int i = 0; i != strace.length; ++i) {
      strace[i] = list.frameAt(i).toStackTraceElement();
    }
    return strace;
  }
}