public FilteredLogTableModel() 
{
  //--------------------------------------------------------------------------
  //   Private Variables:
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  //   Constructors:
  //--------------------------------------------------------------------------
    super();
}

 public synchronized boolean addLogRecord(LogRecord record) 
{
    _allRecords.add(record);
    if (_filter.passes(record) == false) {
      return false;
    }
    getFilteredRecords().add(record);
    fireTableRowsInserted(getRowCount(), getRowCount());
    trimRecords();
    return true;
}

 public synchronized  void clear() 
{
    _allRecords.clear();
    _filteredRecords.clear();
    fireTableDataChanged();
}

Clears all records from the LogTableModel

 protected List createFilteredRecordsList() 
{
    List result = new ArrayList();
    Iterator records = _allRecords.iterator();
    LogRecord current;
    while (records.hasNext()) {
      current = (LogRecord) records.next();
      if (_filter.passes(current)) {
        result.add(current);
      }
    }
    return result;
}

 public synchronized  void fastRefresh() 
{
    _filteredRecords.remove(0);
    fireTableRowsDeleted(0, 0);
}

 protected Object getColumn(int col,
    LogRecord lr) 
{
    if (lr == null) {
      return "NULL Column";
    }
    String date = new Date(lr.getMillis()).toString();
    switch (col) {
      case 0:
        return date + " (" + lr.getMillis() + ")";
      case 1:
        return lr.getThreadDescription();
      case 2:
        return new Long(lr.getSequenceNumber());
      case 3:
        return lr.getLevel();
      case 4:
        return lr.getNDC();
      case 5:
        return lr.getCategory();
      case 6:
        return lr.getMessage();
      case 7:
        return lr.getLocation();
      case 8:
        return lr.getThrownStackTrace();
      default:
        String message = "The column number " + col + "must be between 0 and 8";
        throw new IllegalArgumentException(message);
    }
}

 public int getColumnCount() 
{
    return _colNames.length;
}

 public String getColumnName(int i) 
{
    return _colNames[i];
}

 protected LogRecord getFilteredRecord(int row) 
{
    List records = getFilteredRecords();
    int size = records.size();
    if (row <  size) {
      return (LogRecord) records.get(row);
    }
    // a minor problem has happened. JTable has asked for
    // a row outside the bounds, because the size of
    // _filteredRecords has changed while it was looping.
    // return the last row.
    return (LogRecord) records.get(size - 1);
}

 protected List getFilteredRecords() 
{
    if (_filteredRecords == null) {
      refresh();
    }
    return _filteredRecords;
}

 public LogRecordFilter getLogRecordFilter() 
{
    return _filter;
}

 public int getRowCount() 
{
    return getFilteredRecords().size();
}

 public int getTotalRowCount() 
{
    return _allRecords.size();
}

 public Object getValueAt(int row,
    int col) 
{
    LogRecord record = getFilteredRecord(row);
    return getColumn(col, record);
}

 protected boolean needsTrimming() 
{
    return (_allRecords.size()  > _maxNumberOfLogRecords);
}

 public synchronized  void refresh() 
{
    _filteredRecords = createFilteredRecordsList();
    fireTableDataChanged();
}

Forces the LogTableModel to requery its filters to determine which records to display.

 public  void setLogRecordFilter(LogRecordFilter filter) 
{
    _filter = filter;
}

 public  void setMaxNumberOfLogRecords(int maxNumRecords) 
{
    if (maxNumRecords  > 0) {
      _maxNumberOfLogRecords = maxNumRecords;
    }
}

 protected  void trimOldestRecords() 
{
    synchronized (_allRecords) {
      int trim = numberOfRecordsToTrim();
      if (trim  > 1) {
        List oldRecords =
            _allRecords.subList(0, trim);
        oldRecords.clear();
        refresh();
      } else {
        _allRecords.remove(0);
        fastRefresh();
      }
    }
}

 protected  void trimRecords() 
{
    if (needsTrimming()) {
      trimOldestRecords();
    }
}