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  
18  package org.apache.log4j.chainsaw;
19  
20  import org.apache.log4j.helpers.Constants;
21  import org.apache.log4j.spi.LoggingEvent;
22  
23  import java.util.Comparator;
24  
25  
26  /**
27   * @author Claude Duguay
28   * @author Paul Smith <psmith@apache.org>
29   * @author Scott Deboy <sdeboy@apache.org>
30   */
31  public class ColumnComparator implements Comparator {
32      protected int index;
33      protected boolean ascending;
34      protected String columnName;
35  
36      public ColumnComparator(String columnName, int index, boolean ascending) {
37          this.columnName = columnName;
38          this.index = index;
39          this.ascending = ascending;
40      }
41  
42      public int compare(Object o1, Object o2) {
43          int sort = 1;
44  
45          if (o1 instanceof LoggingEventWrapper && o2 instanceof LoggingEventWrapper) {
46  
47  //		TODO not everything catered for here yet...
48  
49              LoggingEvent e1 = ((LoggingEventWrapper) o1).getLoggingEvent();
50              LoggingEvent e2 = ((LoggingEventWrapper) o2).getLoggingEvent();
51  
52              switch (index + 1) {
53                  case ChainsawColumns.INDEX_LEVEL_COL_NAME:
54                      sort = e1.getLevel().isGreaterOrEqual(e2.getLevel()) ? 1 : (-1);
55  
56                      break;
57  
58                  case ChainsawColumns.INDEX_LOGGER_COL_NAME:
59                      sort = e1.getLoggerName().compareToIgnoreCase(e2.getLoggerName());
60  
61                      break;
62  
63                  case ChainsawColumns.INDEX_MESSAGE_COL_NAME:
64                      sort =
65                          e1.getMessage().toString().compareToIgnoreCase(
66                              e2.getMessage().toString());
67  
68                      break;
69  
70                  case ChainsawColumns.INDEX_NDC_COL_NAME:
71                      if (e1.getNDC() != null && e2.getNDC() != null) {
72                          sort =
73                              e1.getNDC().compareToIgnoreCase(
74                                  e2.getNDC());
75                      } else if (e1.getNDC() == null && e2.getNDC() == null) {
76                          sort = 0;
77                      } else if (e1.getNDC() == null) {
78                          sort = -1;
79                      } else if (e2.getNDC() == null) {
80                          sort = 1;
81                      }
82  
83                      break;
84  
85                  case ChainsawColumns.INDEX_METHOD_COL_NAME:
86  
87                      if (
88                          (e1.locationInformationExists())
89                              & (e2.locationInformationExists())) {
90                          sort =
91                              e1.getLocationInformation().getMethodName().compareToIgnoreCase(
92                                  e2.getLocationInformation().getMethodName());
93                      }
94  
95                      break;
96  
97                  case ChainsawColumns.INDEX_CLASS_COL_NAME:
98  
99                      if (
100                         (e1.locationInformationExists())
101                             & (e2.locationInformationExists())) {
102                         sort =
103                             e1.getLocationInformation().getClassName().compareToIgnoreCase(
104                                 e2.getLocationInformation().getClassName());
105                     }
106 
107                     break;
108 
109                 case ChainsawColumns.INDEX_FILE_COL_NAME:
110 
111                     if (
112                         (e1.locationInformationExists())
113                             & (e2.locationInformationExists())) {
114                         sort =
115                             e1.getLocationInformation().getFileName().compareToIgnoreCase(
116                                 e2.getLocationInformation().getFileName());
117                     }
118 
119                     break;
120 
121                 case ChainsawColumns.INDEX_TIMESTAMP_COL_NAME:
122                     sort = (Long.compare(e1.getTimeStamp(), e2.getTimeStamp()));
123                     break;
124 
125                 case ChainsawColumns.INDEX_THREAD_COL_NAME:
126                     sort = e1.getThreadName().compareToIgnoreCase(e2.getThreadName());
127                     break;
128 
129                 case ChainsawColumns.INDEX_ID_COL_NAME:
130                     int id1 = Integer.parseInt(e1.getProperty(Constants.LOG4J_ID_KEY));
131                     int id2 = Integer.parseInt(e2.getProperty(Constants.LOG4J_ID_KEY));
132                     sort = Integer.compare(id2, id1);
133                     break;
134 
135                 case ChainsawColumns.INDEX_THROWABLE_COL_NAME:
136                     if (e1.getThrowableStrRep() != null && e2.getThrowableStrRep() != null) {
137                         String[] s1 = e1.getThrowableStrRep();
138                         String[] s2 = e2.getThrowableStrRep();
139                         boolean foundDiff = false;
140                         for (int i = 0; i < s1.length; i++) {
141                             if (foundDiff || i > s2.length) {
142                                 break;
143                             }
144                             sort = s1[i].compareToIgnoreCase(s2[i]);
145                             foundDiff = sort != 0;
146                         }
147                     }
148                     break;
149 
150                 case ChainsawColumns.INDEX_LINE_COL_NAME:
151                     if (
152                         (e1.locationInformationExists())
153                             & (e2.locationInformationExists())) {
154                         sort =
155                             e1.getLocationInformation().getLineNumber().compareToIgnoreCase(
156                                 e2.getLocationInformation().getLineNumber());
157                     }
158                     break;
159 
160                 //other columns may be Property values - see if there is an Property value matching column name
161                 default:
162                     if (e1.getProperty(columnName) != null && e2.getProperty(columnName) != null) {
163                         sort = e1.getProperty(columnName).compareToIgnoreCase(e2.getProperty(columnName));
164                     }
165             }
166         }
167 
168         sort = Integer.compare(sort, 0);
169 
170         if (!ascending && (sort != 0)) {
171             sort = (sort < 0) ? 1 : (-1);
172         }
173 
174         return sort;
175     }
176 }