KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > taglibs > standard > lang > jstl > Logger


1 /*
2  * Copyright 1999-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16
17 package org.apache.taglibs.standard.lang.jstl;
18
19 import java.io.PrintStream JavaDoc;
20 import java.text.MessageFormat JavaDoc;
21
22 /**
23  *
24  * <p>The evaluator may pass an instance of this class to operators
25  * and expressions during evaluation. They should use this to log any
26  * warning or error messages that might come up. This allows all of
27  * our logging policies to be concentrated in one class.
28  *
29  * <p>Errors are conditions that are severe enough to abort operation.
30  * Warnings are conditions through which the operation may continue,
31  * but which should be reported to the developer.
32  *
33  * @author Nathan Abramson - Art Technology Group
34  * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author: pierred $
35  **/

36
37 public class Logger
38 {
39   //-------------------------------------
40
// Member variables
41
//-------------------------------------
42

43   PrintStream JavaDoc mOut;
44
45   //-------------------------------------
46
/**
47    *
48    * Constructor
49    *
50    * @param pOut the PrintStream to which warnings should be printed
51    **/

52   public Logger (PrintStream JavaDoc pOut)
53   {
54     mOut = pOut;
55   }
56
57   //-------------------------------------
58
/**
59    *
60    * Returns true if the application should even bother to try logging
61    * a warning.
62    **/

63   public boolean isLoggingWarning ()
64   {
65     return false;
66   }
67
68   //-------------------------------------
69
/**
70    *
71    * Logs a warning
72    **/

73   public void logWarning (String JavaDoc pMessage,
74               Throwable JavaDoc pRootCause)
75     throws ELException
76   {
77     if (isLoggingWarning ()) {
78       if (pMessage == null) {
79     System.out.println (pRootCause);
80       }
81       else if (pRootCause == null) {
82     System.out.println (pMessage);
83       }
84       else {
85     System.out.println (pMessage + ": " + pRootCause);
86       }
87     }
88   }
89
90   //-------------------------------------
91
/**
92    *
93    * Logs a warning
94    **/

95   public void logWarning (String JavaDoc pTemplate)
96     throws ELException
97   {
98     if (isLoggingWarning ()) {
99       logWarning (pTemplate, null);
100     }
101   }
102
103   //-------------------------------------
104
/**
105    *
106    * Logs a warning
107    **/

108   public void logWarning (Throwable JavaDoc pRootCause)
109     throws ELException
110   {
111     if (isLoggingWarning ()) {
112       logWarning (null, pRootCause);
113     }
114   }
115
116   //-------------------------------------
117
/**
118    *
119    * Logs a warning
120    **/

121   public void logWarning (String JavaDoc pTemplate,
122               Object JavaDoc pArg0)
123     throws ELException
124   {
125     if (isLoggingWarning ()) {
126       logWarning
127     (MessageFormat.format
128      (pTemplate,
129       new Object JavaDoc [] {
130         "" + pArg0,
131       }));
132     }
133   }
134
135   //-------------------------------------
136
/**
137    *
138    * Logs a warning
139    **/

140   public void logWarning (String JavaDoc pTemplate,
141               Throwable JavaDoc pRootCause,
142               Object JavaDoc pArg0)
143     throws ELException
144   {
145     if (isLoggingWarning ()) {
146       logWarning
147     (MessageFormat.format
148      (pTemplate,
149       new Object JavaDoc [] {
150         "" + pArg0,
151       }),
152      pRootCause);
153     }
154   }
155
156   //-------------------------------------
157
/**
158    *
159    * Logs a warning
160    **/

161   public void logWarning (String JavaDoc pTemplate,
162               Object JavaDoc pArg0,
163               Object JavaDoc pArg1)
164     throws ELException
165   {
166     if (isLoggingWarning ()) {
167       logWarning
168     (MessageFormat.format
169      (pTemplate,
170       new Object JavaDoc [] {
171         "" + pArg0,
172         "" + pArg1,
173       }));
174     }
175   }
176
177   //-------------------------------------
178
/**
179    *
180    * Logs a warning
181    **/

182   public void logWarning (String JavaDoc pTemplate,
183               Throwable JavaDoc pRootCause,
184               Object JavaDoc pArg0,
185               Object JavaDoc pArg1)
186     throws ELException
187   {
188     if (isLoggingWarning ()) {
189       logWarning
190     (MessageFormat.format
191      (pTemplate,
192       new Object JavaDoc [] {
193         "" + pArg0,
194         "" + pArg1,
195       }),
196      pRootCause);
197     }
198   }
199
200   //-------------------------------------
201
/**
202    *
203    * Logs a warning
204    **/

205   public void logWarning (String JavaDoc pTemplate,
206               Object JavaDoc pArg0,
207               Object JavaDoc pArg1,
208               Object JavaDoc pArg2)
209     throws ELException
210   {
211     if (isLoggingWarning ()) {
212       logWarning
213     (MessageFormat.format
214      (pTemplate,
215       new Object JavaDoc [] {
216         "" + pArg0,
217         "" + pArg1,
218         "" + pArg2,
219       }));
220     }
221   }
222
223   //-------------------------------------
224
/**
225    *
226    * Logs a warning
227    **/

228   public void logWarning (String JavaDoc pTemplate,
229               Throwable JavaDoc pRootCause,
230               Object JavaDoc pArg0,
231               Object JavaDoc pArg1,
232               Object JavaDoc pArg2)
233     throws ELException
234   {
235     if (isLoggingWarning ()) {
236       logWarning
237     (MessageFormat.format
238      (pTemplate,
239       new Object JavaDoc [] {
240         "" + pArg0,
241         "" + pArg1,
242         "" + pArg2,
243       }),
244      pRootCause);
245     }
246   }
247
248   //-------------------------------------
249
/**
250    *
251    * Logs a warning
252    **/

253   public void logWarning (String JavaDoc pTemplate,
254               Object JavaDoc pArg0,
255               Object JavaDoc pArg1,
256               Object JavaDoc pArg2,
257               Object JavaDoc pArg3)
258     throws ELException
259   {
260     if (isLoggingWarning ()) {
261       logWarning
262     (MessageFormat.format
263      (pTemplate,
264       new Object JavaDoc [] {
265         "" + pArg0,
266         "" + pArg1,
267         "" + pArg2,
268         "" + pArg3,
269       }));
270     }
271   }
272
273   //-------------------------------------
274
/**
275    *
276    * Logs a warning
277    **/

278   public void logWarning (String JavaDoc pTemplate,
279               Throwable JavaDoc pRootCause,
280               Object JavaDoc pArg0,
281               Object JavaDoc pArg1,
282               Object JavaDoc pArg2,
283               Object JavaDoc pArg3)
284     throws ELException
285   {
286     if (isLoggingWarning ()) {
287       logWarning
288     (MessageFormat.format
289      (pTemplate,
290       new Object JavaDoc [] {
291         "" + pArg0,
292         "" + pArg1,
293         "" + pArg2,
294         "" + pArg3,
295       }),
296      pRootCause);
297     }
298   }
299
300   //-------------------------------------
301
/**
302    *
303    * Logs a warning
304    **/

305   public void logWarning (String JavaDoc pTemplate,
306               Object JavaDoc pArg0,
307               Object JavaDoc pArg1,
308               Object JavaDoc pArg2,
309               Object JavaDoc pArg3,
310               Object JavaDoc pArg4)
311     throws ELException
312   {
313     if (isLoggingWarning ()) {
314       logWarning
315     (MessageFormat.format
316      (pTemplate,
317       new Object JavaDoc [] {
318         "" + pArg0,
319         "" + pArg1,
320         "" + pArg2,
321         "" + pArg3,
322         "" + pArg4,
323       }));
324     }
325   }
326
327   //-------------------------------------
328
/**
329    *
330    * Logs a warning
331    **/

332   public void logWarning (String JavaDoc pTemplate,
333               Throwable JavaDoc pRootCause,
334               Object JavaDoc pArg0,
335               Object JavaDoc pArg1,
336               Object JavaDoc pArg2,
337               Object JavaDoc pArg3,
338               Object JavaDoc pArg4)
339     throws ELException
340   {
341     if (isLoggingWarning ()) {
342       logWarning
343     (MessageFormat.format
344      (pTemplate,
345       new Object JavaDoc [] {
346         "" + pArg0,
347         "" + pArg1,
348         "" + pArg2,
349         "" + pArg3,
350         "" + pArg4,
351       }),
352      pRootCause);
353     }
354   }
355
356   //-------------------------------------
357
/**
358    *
359    * Logs a warning
360    **/

361   public void logWarning (String JavaDoc pTemplate,
362               Object JavaDoc pArg0,
363               Object JavaDoc pArg1,
364               Object JavaDoc pArg2,
365               Object JavaDoc pArg3,
366               Object JavaDoc pArg4,
367               Object JavaDoc pArg5)
368     throws ELException
369   {
370     if (isLoggingWarning ()) {
371       logWarning
372     (MessageFormat.format
373      (pTemplate,
374       new Object JavaDoc [] {
375         "" + pArg0,
376         "" + pArg1,
377         "" + pArg2,
378         "" + pArg3,
379         "" + pArg4,
380         "" + pArg5,
381       }));
382     }
383   }
384
385   //-------------------------------------
386
/**
387    *
388    * Logs a warning
389    **/

390   public void logWarning (String JavaDoc pTemplate,
391               Throwable JavaDoc pRootCause,
392               Object JavaDoc pArg0,
393               Object JavaDoc pArg1,
394               Object JavaDoc pArg2,
395               Object JavaDoc pArg3,
396               Object JavaDoc pArg4,
397               Object JavaDoc pArg5)
398     throws ELException
399   {
400     if (isLoggingWarning ()) {
401       logWarning
402     (MessageFormat.format
403      (pTemplate,
404       new Object JavaDoc [] {
405         "" + pArg0,
406         "" + pArg1,
407         "" + pArg2,
408         "" + pArg3,
409         "" + pArg4,
410         "" + pArg5,
411       }),
412      pRootCause);
413     }
414   }
415
416   //-------------------------------------
417
/**
418    *
419    * Returns true if the application should even bother to try logging
420    * an error.
421    **/

422   public boolean isLoggingError ()
423   {
424     return true;
425   }
426
427   //-------------------------------------
428
/**
429    *
430    * Logs an error
431    **/

432   public void logError (String JavaDoc pMessage,
433             Throwable JavaDoc pRootCause)
434     throws ELException
435   {
436     if (isLoggingError ()) {
437       if (pMessage == null) {
438     throw new ELException (pRootCause);
439       }
440       else if (pRootCause == null) {
441     throw new ELException (pMessage);
442       }
443       else {
444     throw new ELException (pMessage, pRootCause);
445       }
446     }
447   }
448
449   //-------------------------------------
450
/**
451    *
452    * Logs an error
453    **/

454   public void logError (String JavaDoc pTemplate)
455     throws ELException
456   {
457     if (isLoggingError ()) {
458       logError (pTemplate, null);
459     }
460   }
461
462   //-------------------------------------
463
/**
464    *
465    * Logs an error
466    **/

467   public void logError (Throwable JavaDoc pRootCause)
468     throws ELException
469   {
470     if (isLoggingError ()) {
471       logError (null, pRootCause);
472     }
473   }
474
475   //-------------------------------------
476
/**
477    *
478    * Logs an error
479    **/

480   public void logError (String JavaDoc pTemplate,
481             Object JavaDoc pArg0)
482     throws ELException
483   {
484     if (isLoggingError ()) {
485       logError
486     (MessageFormat.format
487      (pTemplate,
488       new Object JavaDoc [] {
489         "" + pArg0,
490       }));
491     }
492   }
493
494   //-------------------------------------
495
/**
496    *
497    * Logs an error
498    **/

499   public void logError (String JavaDoc pTemplate,
500             Throwable JavaDoc pRootCause,
501             Object JavaDoc pArg0)
502     throws ELException
503   {
504     if (isLoggingError ()) {
505       logError
506     (MessageFormat.format
507      (pTemplate,
508       new Object JavaDoc [] {
509         "" + pArg0,
510       }),
511      pRootCause);
512     }
513   }
514
515   //-------------------------------------
516
/**
517    *
518    * Logs an error
519    **/

520   public void logError (String JavaDoc pTemplate,
521             Object JavaDoc pArg0,
522             Object JavaDoc pArg1)
523     throws ELException
524   {
525     if (isLoggingError ()) {
526       logError
527     (MessageFormat.format
528      (pTemplate,
529       new Object JavaDoc [] {
530         "" + pArg0,
531         "" + pArg1,
532       }));
533     }
534   }
535
536   //-------------------------------------
537
/**
538    *
539    * Logs an error
540    **/

541   public void logError (String JavaDoc pTemplate,
542             Throwable JavaDoc pRootCause,
543             Object JavaDoc pArg0,
544             Object JavaDoc pArg1)
545     throws ELException
546   {
547     if (isLoggingError ()) {
548       logError
549     (MessageFormat.format
550      (pTemplate,
551       new Object JavaDoc [] {
552         "" + pArg0,
553         "" + pArg1,
554       }),
555      pRootCause);
556     }
557   }
558
559   //-------------------------------------
560
/**
561    *
562    * Logs an error
563    **/

564   public void logError (String JavaDoc pTemplate,
565             Object JavaDoc pArg0,
566             Object JavaDoc pArg1,
567             Object JavaDoc pArg2)
568     throws ELException
569   {
570     if (isLoggingError ()) {
571       logError
572     (MessageFormat.format
573      (pTemplate,
574       new Object JavaDoc [] {
575         "" + pArg0,
576         "" + pArg1,
577         "" + pArg2,
578       }));
579     }
580   }
581
582   //-------------------------------------
583
/**
584    *
585    * Logs an error
586    **/

587   public void logError (String JavaDoc pTemplate,
588             Throwable JavaDoc pRootCause,
589             Object JavaDoc pArg0,
590             Object JavaDoc pArg1,
591             Object JavaDoc pArg2)
592     throws ELException
593   {
594     if (isLoggingError ()) {
595       logError
596     (MessageFormat.format
597      (pTemplate,
598       new Object JavaDoc [] {
599         "" + pArg0,
600         "" + pArg1,
601         "" + pArg2,
602       }),
603      pRootCause);
604     }
605   }
606
607   //-------------------------------------
608
/**
609    *
610    * Logs an error
611    **/

612   public void logError (String JavaDoc pTemplate,
613             Object JavaDoc pArg0,
614             Object JavaDoc pArg1,
615             Object JavaDoc pArg2,
616             Object JavaDoc pArg3)
617     throws ELException
618   {
619     if (isLoggingError ()) {
620       logError
621     (MessageFormat.format
622      (pTemplate,
623       new Object JavaDoc [] {
624         "" + pArg0,
625         "" + pArg1,
626         "" + pArg2,
627         "" + pArg3,
628       }));
629     }
630   }
631
632   //-------------------------------------
633
/**
634    *
635    * Logs an error
636    **/

637   public void logError (String JavaDoc pTemplate,
638             Throwable JavaDoc pRootCause,
639             Object JavaDoc pArg0,
640             Object JavaDoc pArg1,
641             Object JavaDoc pArg2,
642             Object JavaDoc pArg3)
643     throws ELException
644   {
645     if (isLoggingError ()) {
646       logError
647     (MessageFormat.format
648      (pTemplate,
649       new Object JavaDoc [] {
650         "" + pArg0,
651         "" + pArg1,
652         "" + pArg2,
653         "" + pArg3,
654       }),
655      pRootCause);
656     }
657   }
658
659   //-------------------------------------
660
/**
661    *
662    * Logs an error
663    **/

664   public void logError (String JavaDoc pTemplate,
665             Object JavaDoc pArg0,
666             Object JavaDoc pArg1,
667             Object JavaDoc pArg2,
668             Object JavaDoc pArg3,
669             Object JavaDoc pArg4)
670     throws ELException
671   {
672     if (isLoggingError ()) {
673       logError
674     (MessageFormat.format
675      (pTemplate,
676       new Object JavaDoc [] {
677         "" + pArg0,
678         "" + pArg1,
679         "" + pArg2,
680         "" + pArg3,
681         "" + pArg4,
682       }));
683     }
684   }
685
686   //-------------------------------------
687
/**
688    *
689    * Logs an error
690    **/

691   public void logError (String JavaDoc pTemplate,
692             Throwable JavaDoc pRootCause,
693             Object JavaDoc pArg0,
694             Object JavaDoc pArg1,
695             Object JavaDoc pArg2,
696             Object JavaDoc pArg3,
697             Object JavaDoc pArg4)
698     throws ELException
699   {
700     if (isLoggingError ()) {
701       logError
702     (MessageFormat.format
703      (pTemplate,
704       new Object JavaDoc [] {
705         "" + pArg0,
706         "" + pArg1,
707         "" + pArg2,
708         "" + pArg3,
709         "" + pArg4,
710       }),
711      pRootCause);
712     }
713   }
714
715   //-------------------------------------
716
/**
717    *
718    * Logs an error
719    **/

720   public void logError (String JavaDoc pTemplate,
721             Object JavaDoc pArg0,
722             Object JavaDoc pArg1,
723             Object JavaDoc pArg2,
724             Object JavaDoc pArg3,
725             Object JavaDoc pArg4,
726             Object JavaDoc pArg5)
727     throws ELException
728   {
729     if (isLoggingError ()) {
730       logError
731     (MessageFormat.format
732      (pTemplate,
733       new Object JavaDoc [] {
734         "" + pArg0,
735         "" + pArg1,
736         "" + pArg2,
737         "" + pArg3,
738         "" + pArg4,
739         "" + pArg5,
740       }));
741     }
742   }
743
744   //-------------------------------------
745
/**
746    *
747    * Logs an error
748    **/

749   public void logError (String JavaDoc pTemplate,
750             Throwable JavaDoc pRootCause,
751             Object JavaDoc pArg0,
752             Object JavaDoc pArg1,
753             Object JavaDoc pArg2,
754             Object JavaDoc pArg3,
755             Object JavaDoc pArg4,
756             Object JavaDoc pArg5)
757     throws ELException
758   {
759     if (isLoggingError ()) {
760       logError
761     (MessageFormat.format
762      (pTemplate,
763       new Object JavaDoc [] {
764         "" + pArg0,
765         "" + pArg1,
766         "" + pArg2,
767         "" + pArg3,
768         "" + pArg4,
769         "" + pArg5,
770       }),
771      pRootCause);
772     }
773   }
774
775   //-------------------------------------
776
}
777
Popular Tags