View Javadoc
1   package net.logAnalyzer.reports;
2   
3   import net.logAnalyzer.analysis.LAAnalysis;
4   import net.logAnalyzer.analysis.LAAnalyzer;
5   import net.logAnalyzer.analysis.MultiValuesAnalysis;
6   import net.logAnalyzer.analysis.SingleValueAnalysis;
7   
8   /***
9    * Generates TXT reports from analyzers results. Each analysis is serialized in
10   * a textual tabulated format according to the class of its result.
11   * <p>
12   * Each report returned by {@link #render()} is a String wrapped in a
13   * {@link net.logAnalyzer.reports.TXTReport}.
14   * </p>
15   * 
16   * @author Karim REFEYTON
17   * @version 0.1
18   */
19  public class TXTReportRenderer implements LAReportRenderer {
20      /***
21       * Default delimiter (tabulation).
22       */
23      public static final char DEFAULT_DELIMITER = '\t';
24  
25      /***
26       * LAReportRenderer definition.
27       */
28      private RendererDefinition definition = null;
29  
30      /***
31       * Analyzers to include in the reports.
32       */
33      private LAAnalyzer[] analyzers = null;
34  
35      /***
36       * Creates a new report for each specified analyzer.
37       * 
38       * @param definition
39       *            Renderer definition.
40       * @param analyzers
41       *            Analyzers to report.
42       */
43      public TXTReportRenderer(RendererDefinition definition,
44              LAAnalyzer[] analyzers) {
45          this.definition = definition;
46          this.analyzers = analyzers;
47      }
48  
49      /***
50       * Returns the name of the analyzer.
51       * 
52       * @return LAAnalyzer name.
53       * @see LAReportRenderer#getName()
54       */
55      public String getName() {
56          return definition.getName();
57      }
58  
59      /***
60       * Renders the reports. Each report is a {@link TXTReport} wrapping a
61       * {@link String} containing a textual tabulated representation of an
62       * analyzer result. <br>
63       * Uses the default delimiter {@link #DEFAULT_DELIMITER}.
64       * 
65       * @return Generated reports.
66       * @throws ReportException
67       * @see LAReportRenderer#render()
68       */
69      public LAReport[] render() throws ReportException {
70          return render(DEFAULT_DELIMITER);
71      }
72  
73      /***
74       * Renders the report. Uses the specified delimiter.
75       * 
76       * @param delimiter
77       *            Field delimiter.
78       * @return Generated reports.
79       * @throws ReportException
80       */
81      public LAReport[] render(char delimiter) throws ReportException {
82          LAReport[] reports = new LAReport[analyzers.length];
83          if (analyzers != null && analyzers.length > 0) {
84              for (int i = 0; i < analyzers.length; i++) {
85                  reports[i] = new TXTReport(analyzers[i].getName(),
86                          renderAnalyze(delimiter, analyzers[i].getAnalysis()));
87              }
88          }
89          return reports;
90      }
91  
92      /***
93       * Empty method to avoid loops on unsupported analysis.
94       * 
95       * @param delimiter
96       *            Field delimiter.
97       * @param analysis
98       *            Analysis to render.
99       * @return String report.
100      */
101     protected String renderAnalyze(char delimiter, LAAnalysis analysis) {
102         if (analysis instanceof SingleValueAnalysis) {
103             return renderAnalyze(delimiter, (SingleValueAnalysis) analysis);
104         } else if (analysis instanceof MultiValuesAnalysis) {
105             return renderAnalyze(delimiter, (MultiValuesAnalysis) analysis);
106         } else {
107             return null;
108         }
109     }
110 
111     /***
112      * Renders a key values result in a file called [<tt><i>analyzername</i></tt>].
113      * File format :
114      * 
115      * <table>
116      * <tr>
117      * <th>key</th>
118      * <td><i>{delimiter}</i></td>
119      * <th>valueName</th>
120      * </tr>
121      * <tr>
122      * <td><i>key[1]</i></td>
123      * <td><i>{delimiter}</i></td>
124      * <td><i>value[1]</i></td>
125      * </tr>
126      * <tr>
127      * <td><i>key[2]</i></td>
128      * <td><i>{delimiter}</i></td>
129      * <td><i>value[2]</i></td>
130      * </tr>
131      * <tr>
132      * <td><i>...</i></td>
133      * <td><i>{delimiter}</i></td>
134      * <td><i>...</i></td>
135      * </tr>
136      * </table>
137      * 
138      * @param delimiter
139      *            Field delimiter.
140      * @param analysis
141      *            Analysis to render.
142      * @return String report.
143      */
144     protected String renderAnalyze(char delimiter, SingleValueAnalysis analysis) {
145         StringBuffer newReport = new StringBuffer();
146         // Serialize the header
147         newReport.append("key").append(delimiter).append(analysis.getName())
148                 .append("\n");
149         // Serialize the values and keys
150         for (int i = 0; i < analysis.size(); i++) {
151             Comparable key = analysis.getKey(i);
152             newReport.append(analysis.getStringKey(i)).append(delimiter)
153                     .append(analysis.getString(key)).append("\n");
154         }
155         // Close the report
156         newReport.append("\n");
157         // Returns the report
158         return newReport.toString();
159     }
160 
161     /***
162      * Renders a multi values result in a file called [<tt><i>analyzername</i></tt>].
163      * File format :
164      * 
165      * <table>
166      * <tr>
167      * <th>key</th>
168      * <td><i>{delimiter}</i></td>
169      * <th>valueName1</th>
170      * <td><i>{delimiter}</i></td>
171      * <th>valueName2</th>
172      * <td><i>{delimiter}</i></td>
173      * <th>...</th>
174      * </tr>
175      * <tr>
176      * <td><i>key[1]</i></td>
177      * <td><i>{delimiter}</i></td>
178      * <td><i>value1[1]</i></td>
179      * <td><i>{delimiter}</i></td>
180      * <td><i>value2[1]</i></td>
181      * <td><i>{delimiter}</i></td>
182      * <td><i>...</i></td>
183      * </tr>
184      * <tr>
185      * <td><i>key[2]</i></td>
186      * <td><i>{delimiter}</i></td>
187      * <td><i>value1[2]</i></td>
188      * <td><i>{delimiter}</i></td>
189      * <td><i>value2[1]</i></td>
190      * <td><i>{delimiter}</i></td>
191      * <td><i>...</i></td>
192      * </tr>
193      * <tr>
194      * <td><i>...</i></td>
195      * <td><i>{delimiter}</i></td>
196      * <td><i>...</i></td>
197      * <td><i>{delimiter}</i></td>
198      * <td><i>...</i></td>
199      * <td><i>{delimiter}</i></td>
200      * <td><i>...</i></td>
201      * </tr>
202      * </table>
203      * 
204      * @param delimiter
205      *            Field delimiter.
206      * @param analysis
207      *            Analysis to render.
208      * @return String report.
209      */
210     protected String renderAnalyze(char delimiter, MultiValuesAnalysis analysis) {
211         StringBuffer newReport = new StringBuffer();
212         // Serialize the header
213         String[] valuesNames = analysis.getNames();
214         newReport.append("key");
215         for (int i = 0; i < valuesNames.length; i++) {
216             newReport.append(delimiter).append(valuesNames[i]);
217         }
218         newReport.append("\n");
219         // Serialize the values and keys
220         for (int i = 0; i < analysis.size(); i++) {
221             Comparable key = analysis.getKey(i);
222             newReport.append(analysis.getStringKey(i));
223             for (int j = 0; j < valuesNames.length; j++) {
224                 newReport.append(delimiter).append(analysis.getString(key, j));
225             }
226             newReport.append("\n");
227         }
228         // Close the report
229         newReport.append("\n");
230         // Returns the report
231         return newReport.toString();
232     }
233 }