FilteredLogTableModel xref

View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17  package org.apache.log4j.lf5.viewer;
    18
    19  import org.apache.log4j.lf5.LogRecord;
    20  import org.apache.log4j.lf5.LogRecordFilter;
    21  import org.apache.log4j.lf5.PassingLogRecordFilter;
    22
    23  import javax.swing.table.AbstractTableModel;
    24  import java.util.ArrayList;
    25  import java.util.Date;
    26  import java.util.Iterator;
    27  import java.util.List;
    28
    29
    30  /**
    31   * A TableModel for LogRecords which includes filtering support.
    32   *
    33   * @author Richard Wan
    34   * @author Brent Sprecher
    35   */
    36
    37  // Contributed by ThoughtWorks Inc.
    38
    39  public class FilteredLogTableModel
    40      extends AbstractTableModel {
    41    //--------------------------------------------------------------------------
    42    //   Constants:
    43    //--------------------------------------------------------------------------
    44
    45    //--------------------------------------------------------------------------
    46    //   Protected Variables:
    47    //--------------------------------------------------------------------------
    48
    49    protected LogRecordFilter _filter = new PassingLogRecordFilter();
    50    protected List _allRecords = new ArrayList();
    51    protected List _filteredRecords;
    52    protected int _maxNumberOfLogRecords = 5000;
    53    protected String[] _colNames = {"Date",
    54                                    "Thread",
    55                                    "Message #",
    56                                    "Level",
    57                                    "NDC",
    58                                    "Category",
    59                                    "Message",
    60                                    "Location",
    61                                    "Thrown"};
    62
    63    //--------------------------------------------------------------------------
    64    //   Private Variables:
    65    //--------------------------------------------------------------------------
    66
    67    //--------------------------------------------------------------------------
    68    //   Constructors:
    69    //--------------------------------------------------------------------------
    70
    71    public FilteredLogTableModel() {
    72      super();
    73    }
    74
    75    //--------------------------------------------------------------------------
    76    //   Public Methods:
    77    //--------------------------------------------------------------------------
    78
    79    public void setLogRecordFilter(LogRecordFilter filter) {
    80      _filter = filter;
    81    }
    82
    83    public LogRecordFilter getLogRecordFilter() {
    84      return _filter;
    85    }
    86
    87    public String getColumnName(int i) {
    88      return _colNames[i];
    89    }
    90
    91    public int getColumnCount() {
    92      return _colNames.length;
    93    }
    94
    95    public int getRowCount() {
    96      return getFilteredRecords().size();
    97    }
    98
    99    public int getTotalRowCount() {
    100     return _allRecords.size();
    101   }
    102
    103   public Object getValueAt(int row, int col) {
    104     LogRecord record = getFilteredRecord(row);
    105     return getColumn(col, record);
    106   }
    107
    108   public void setMaxNumberOfLogRecords(int maxNumRecords) {
    109     if (maxNumRecords > 0) {
    110       _maxNumberOfLogRecords = maxNumRecords;
    111     }
    112
    113   }
    114
    115   public synchronized boolean addLogRecord(LogRecord record) {
    116
    117     _allRecords.add(record);
    118
    119     if (_filter.passes(record) == false) {
    120       return false;
    121     }
    122     getFilteredRecords().add(record);
    123     fireTableRowsInserted(getRowCount(), getRowCount());
    124     trimRecords();
    125     return true;
    126   }
    127
    128   /**
    129    * Forces the LogTableModel to requery its filters to determine
    130    * which records to display.
    131    */
    132   public synchronized void refresh() {
    133     _filteredRecords = createFilteredRecordsList();
    134     fireTableDataChanged();
    135   }
    136
    137   public synchronized void fastRefresh() {
    138     _filteredRecords.remove(0);
    139     fireTableRowsDeleted(0, 0);
    140   }
    141
    142
    143   /**
    144    * Clears all records from the LogTableModel
    145    */
    146   public synchronized void clear() {
    147     _allRecords.clear();
    148     _filteredRecords.clear();
    149     fireTableDataChanged();
    150   }
    151
    152   //--------------------------------------------------------------------------
    153   //   Protected Methods:
    154   //--------------------------------------------------------------------------
    155
    156   protected List getFilteredRecords() {
    157     if (_filteredRecords == null) {
    158       refresh();
    159     }
    160     return _filteredRecords;
    161   }
    162
    163   protected List createFilteredRecordsList() {
    164     List result = new ArrayList();
    165     Iterator records = _allRecords.iterator();
    166     LogRecord current;
    167     while (records.hasNext()) {
    168       current = (LogRecord) records.next();
    169       if (_filter.passes(current)) {
    170         result.add(current);
    171       }
    172     }
    173     return result;
    174   }
    175
    176   protected LogRecord getFilteredRecord(int row) {
    177     List records = getFilteredRecords();
    178     int size = records.size();
    179     if (row < size) {
    180       return (LogRecord) records.get(row);
    181     }
    182     // a minor problem has happened. JTable has asked for
    183     // a row outside the bounds, because the size of
    184     // _filteredRecords has changed while it was looping.
    185     // return the last row.
    186     return (LogRecord) records.get(size - 1);
    187
    188   }
    189
    190   protected Object getColumn(int col, LogRecord lr) {
    191     if (lr == null) {
    192       return "NULL Column";
    193     }
    194     String date = new Date(lr.getMillis()).toString();
    195     switch (col) {
    196       case 0:
    197         return date + " (" + lr.getMillis() + ")";
    198       case 1:
    199         return lr.getThreadDescription();
    200       case 2:
    201         return new Long(lr.getSequenceNumber());
    202       case 3:
    203         return lr.getLevel();
    204       case 4:
    205         return lr.getNDC();
    206       case 5:
    207         return lr.getCategory();
    208       case 6:
    209         return lr.getMessage();
    210       case 7:
    211         return lr.getLocation();
    212       case 8:
    213         return lr.getThrownStackTrace();
    214       default:
    215         String message = "The column number " + col + "must be between 0 and 8";
    216         throw new IllegalArgumentException(message);
    217     }
    218   }
    219
    220   // We don't want the amount of rows to grow without bound,
    221   // leading to a out-of-memory-exception.  Especially not good
    222   // in a production environment :)
    223
    224   // This method & clearLogRecords() are synchronized so we don't
    225   // delete rows that don't exist.
    226   protected void trimRecords() {
    227     if (needsTrimming()) {
    228       trimOldestRecords();
    229     }
    230   }
    231
    232   protected boolean needsTrimming() {
    233     return (_allRecords.size() > _maxNumberOfLogRecords);
    234   }
    235
    236   protected void trimOldestRecords() {
    237     synchronized (_allRecords) {
    238       int trim = numberOfRecordsToTrim();
    239       if (trim > 1) {
    240         List oldRecords =
    241             _allRecords.subList(0, trim);
    242         oldRecords.clear();
    243         refresh();
    244       } else {
    245         _allRecords.remove(0);
    246         fastRefresh();
    247       }
    248     }
    249
    250   }
    251
    252   //--------------------------------------------------------------------------
    253   //   Private Methods:
    254   //--------------------------------------------------------------------------
    255   private int numberOfRecordsToTrim() {
    256     return _allRecords.size() - _maxNumberOfLogRecords;
    257   }
    258
    259   //--------------------------------------------------------------------------
    260   //   Nested Top-Level Classes or Interfaces
    261   //--------------------------------------------------------------------------
    262 }
    263