KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > tools > common > util > diagnostics > ReporterImpl


1 /*
2  * The contents of this file are subject to the terms
3  * of the Common Development and Distribution License
4  * (the License). You may not use this file except in
5  * compliance with the License.
6  *
7  * You can obtain a copy of the license at
8  * https://glassfish.dev.java.net/public/CDDLv1.0.html or
9  * glassfish/bootstrap/legal/CDDLv1.0.txt.
10  * See the License for the specific language governing
11  * permissions and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL
14  * Header Notice in each file and include the License file
15  * at glassfish/bootstrap/legal/CDDLv1.0.txt.
16  * If applicable, add the following below the CDDL Header,
17  * with the fields enclosed by brackets [] replaced by
18  * you own identifying information:
19  * "Portions Copyrighted [year] [name of copyright owner]"
20  *
21  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
22  */
23
24 package com.sun.enterprise.tools.common.util.diagnostics;
25
26 import java.io.*;
27 import java.util.*;
28 import com.sun.enterprise.tools.common.util.Assertion;
29 import com.sun.enterprise.tools.common.util.ObjectAnalyzer;
30 //import netscape.toolutil.util.*;
31 //import netscape.toolutil.util.Registry;
32
33 /** General Purpose Debugging Output
34  ** -- create a ReporterImpl object and then write with
35  ** pr()
36  ** If you construct with an Object -- that Object's class name will automatically be prepended to each message
37  ** If you use pr(String metName, String mesg) -- the metName will be added to the ObjectName
38  ** The output of ReporterImpl is controlled by an environmental variable
39  ** if you call it with java -DaibDebug=true -- it gets turned on...
40  **/
41
42 public class ReporterImpl implements IReporterEnum
43 {
44
45     public ReporterImpl()
46     {
47         ctor(null, -1);
48     }
49     
50     ///////////////////////////////////////////////////////////////////////////////////////////////////////
51
52     ReporterImpl(int theSeverityLevel)
53     {
54         ctor(null, theSeverityLevel);
55     }
56     
57     ///////////////////////////////////////////////////////////////////////////////////////////////////////
58
59     public ReporterImpl(String JavaDoc sid)
60     {
61         ctor(sid, -1);
62     }
63     
64     ///////////////////////////////////////////////////////////////////////////////////////////////////////
65
66     ReporterImpl(String JavaDoc sid, int theSeverityLevel)
67     {
68         ctor(sid, theSeverityLevel);
69     }
70
71     ///////////////////////////////////////////////////////////////////////////////////////////////////////
72 /////////////////////////// //////////////////////////////////////////////////
73 /////////////////////////// Configurating Stuff //////////////////////////////////////////////////
74 /////////////////////////// //////////////////////////////////////////////////
75 ///////////////////////////////////////////////////////////////////////////////////////////////////////
76
77     public void setSeverityLevel(int level)
78     {
79         debug("setSeverityLevel(" + level + ")");//NOI18N
80
81         if(level < 0)
82             level = 0;
83
84         severityLevel = level;
85     }
86
87     ///////////////////////////////////////////////////////////////////////////////////////////////////////
88
89     public void setSeverityLevel(String JavaDoc level)
90     {
91         debug("setSeverityLevel(" + level + ")");//NOI18N
92
93         severityLevel = calcSeverityLevel(level);
94     }
95
96     ///////////////////////////////////////////////////////////////////////////////////////////////////////
97
98     public int getSeverityLevel()
99     {
100         return severityLevel;
101     }
102
103     ///////////////////////////////////////////////////////////////////////////////////////////////////////
104
105     public void setName(String JavaDoc theName)
106     {
107         Assertion.check(theName);
108         name = theName;
109     }
110
111     ///////////////////////////////////////////////////////////////////////////////////////////////////////
112
113     public String JavaDoc getName()
114     {
115         return name;
116     }
117
118     ///////////////////////////////////////////////////////////////////////////////////////////////////////
119 /////////////////////////// //////////////////////////////////////////////////
120 /////////////////////////// Message Writing //////////////////////////////////////////////////
121 /////////////////////////// //////////////////////////////////////////////////
122 ///////////////////////////////////////////////////////////////////////////////////////////////////////
123
124     public void verbose(Object JavaDoc o)
125     {
126         if(checkSeverity(VERBOSE))
127             pr(VERBOSE, o);
128     }
129
130     ///////////////////////////////////////////////////////////////////////////////////////////////////////
131
132     public void info(Object JavaDoc o)
133     {
134         if(checkSeverity(INFO))
135             pr(INFO, o);
136     }
137
138     ///////////////////////////////////////////////////////////////////////////////////////////////////////
139
140     public void warn(Object JavaDoc o)
141     {
142         // convenience method
143 if(checkSeverity(WARN))
144             pr(WARNING, o);
145     }
146
147     ///////////////////////////////////////////////////////////////////////////////////////////////////////
148
149     public void warning(Object JavaDoc o)
150     {
151         if(checkSeverity(WARN))
152             pr(WARNING, o);
153     }
154
155     ///////////////////////////////////////////////////////////////////////////////////////////////////////
156
157     public void error(Object JavaDoc o)
158     {
159         if(checkSeverity(ERROR))
160             pr(ERROR, o);
161     }
162     
163     ///////////////////////////////////////////////////////////////////////////////////////////////////////
164
165     public void critical(Object JavaDoc o)
166     {
167         if(checkSeverity(CRIT))
168             pr(CRITICAL, o);
169     }
170     ///////////////////////////////////////////////////////////////////////////////////////////////////////
171
172     public void crit(Object JavaDoc o)
173     {
174         if(checkSeverity(CRIT))
175             pr(CRITICAL, o);
176     }
177
178     ///////////////////////////////////////////////////////////////////////////////////////////////////////
179
180     public void dump(Object JavaDoc o, String JavaDoc s)
181     {
182         if(checkSeverity(DUMP) && o != null)
183         {
184             if(s == null)
185                 s = ""; // NOI18N
186
187             String JavaDoc s2 = s + "\n********** Object Dump Start ***********\n" +//NOI18N
188 ObjectAnalyzer.toStringWithSuper(o) + "\n********** Object Dump End ***********";//NOI18N
189 pr(OBJECT_DUMP, s2);
190         }
191     }
192
193     ///////////////////////////////////////////////////////////////////////////////////////////////////////
194
195     public void dump(String JavaDoc s)
196     {
197         if(checkSeverity(DUMP))
198         {
199             pr(OBJECT_DUMP, s);
200         }
201     }
202
203
204     ///////////////////////////////////////////////////////////////////////////////////////////////////////
205
206     public void dump(Object JavaDoc o)
207     {
208         dump(o, null);
209     }
210
211     ///////////////////////////////////////////////////////////////////////////////////////////////////////
212 /////////////////////////// //////////////////////////////////////////////////
213 /////////////////////////// ASSERTION STUFF //////////////////////////////////////////////////
214 /////////////////////////// //////////////////////////////////////////////////
215 ///////////////////////////////////////////////////////////////////////////////////////////////////////
216
217     // TBD: Nice to have the assertIt's print the CallerInfo stuff.
218 // lots-o-typing needed!!
219
220     public void assertIt(String JavaDoc s)
221     {
222         if(checkSeverity(ASSERT))
223         {
224             try
225             {
226                 Assertion.check(s);
227             }
228             catch(Assertion.Failure f)
229             {
230                 pr(ASSERT, new StackTrace().toString() + f);
231                 throw f;
232             }
233         }
234     }
235
236     ///////////////////////////////////////////////////////////////////////////////////////////////////////
237
238     public void assertIt(String JavaDoc checkme, String JavaDoc s)
239     {
240         if(checkSeverity(ASSERT))
241         {
242             try
243             {
244                 Assertion.check(checkme, s);
245             }
246             catch(Assertion.Failure f)
247             {
248                 pr(ASSERT, new StackTrace().toString() + f);
249                 throw f;
250             }
251         }
252     }
253
254     ///////////////////////////////////////////////////////////////////////////////////////////////////////
255
256     public void assertIt(boolean b)
257     {
258         if(checkSeverity(ASSERT))
259         {
260             try
261             {
262                 Assertion.check(b);
263             }
264             catch(Assertion.Failure f)
265             {
266                 pr(ASSERT, new StackTrace().toString() + f);
267                 throw f;
268             }
269         }
270     }
271
272     ///////////////////////////////////////////////////////////////////////////////////////////////////////
273
274     public void assertIt(boolean b, String JavaDoc s)
275     {
276         if(checkSeverity(ASSERT))
277         {
278             try
279             {
280                 Assertion.check(b, s);
281             }
282             catch(Assertion.Failure f)
283             {
284                 pr(ASSERT, new StackTrace().toString() + f);
285                 throw f;
286             }
287         }
288     }
289
290     ///////////////////////////////////////////////////////////////////////////////////////////////////////
291
292     public void assertIt(Object JavaDoc o)
293     {
294         if(checkSeverity(ASSERT))
295         {
296             try
297             {
298                 Assertion.check(o);
299             }
300             catch(Assertion.Failure f)
301             {
302                 pr(ASSERT, new StackTrace().toString() + f);
303                 throw f;
304             }
305         }
306     }
307
308     ///////////////////////////////////////////////////////////////////////////////////////////////////////
309
310     public void assertIt(Object JavaDoc o, String JavaDoc s)
311     {
312         if(checkSeverity(ASSERT))
313         {
314             try
315             {
316                 Assertion.check(o, s);
317             }
318             catch(Assertion.Failure f)
319             {
320                 pr(ASSERT, new StackTrace().toString() + f);
321                 throw f;
322             }
323         }
324     }
325
326     ///////////////////////////////////////////////////////////////////////////////////////////////////////
327
328     public void assertIt(double z)
329     {
330         if(checkSeverity(ASSERT))
331         {
332             try
333             {
334                 Assertion.check(z);
335             }
336             catch(Assertion.Failure f)
337             {
338                 pr(ASSERT, new StackTrace().toString() + f);
339                 throw f;
340             }
341         }
342     }
343
344     ///////////////////////////////////////////////////////////////////////////////////////////////////////
345
346     public void assertIt(double z, String JavaDoc s)
347     {
348         if(checkSeverity(ASSERT))
349         {
350             try
351             {
352                 Assertion.check(z, s);
353             }
354             catch(Assertion.Failure f)
355             {
356                 pr(ASSERT, new StackTrace().toString() + f);
357                 throw f;
358             }
359         }
360     }
361
362     ///////////////////////////////////////////////////////////////////////////////////////////////////////
363
364     public void assertIt(long l)
365     {
366         if(checkSeverity(ASSERT))
367         {
368             try
369             {
370                 Assertion.check(l);
371             }
372             catch(Assertion.Failure f)
373             {
374                 pr(ASSERT, new StackTrace().toString() + f);
375                 throw f;
376             }
377         }
378     }
379
380     ///////////////////////////////////////////////////////////////////////////////////////////////////////
381
382     public void assertIt(long l, String JavaDoc s)
383     {
384         if(checkSeverity(ASSERT))
385         {
386             try
387             {
388                 Assertion.check(l, s);
389             }
390             catch(Assertion.Failure f)
391             {
392                 pr(ASSERT, new StackTrace().toString() + f);
393                 throw f;
394             }
395         }
396     }
397         
398         /** Change the mechanism this object uses to deliver output to the user
399          * @param lwriter A new output mechanism
400          * @return The previous output mechanism.
401          */
402         public ReporterWriter setWriter(ReporterWriter lwriter) {
403             ReporterWriter retVal = null;
404             if (null != lwriter) {
405                 retVal = this.writer;
406                 this.writer = lwriter;
407             }
408             return retVal;
409         }
410
411     ///////////////////////////////////////////////////////////////////////////////////////////////////////
412 /////////////////////////// //////////////////////////////////////////////////
413 /////////////////////////// PRIVATE STUFF //////////////////////////////////////////////////
414 /////////////////////////// //////////////////////////////////////////////////
415 ///////////////////////////////////////////////////////////////////////////////////////////////////////
416
417     private void ctor(String JavaDoc theName, int theSeverityLevel)
418     {
419         if(theName != null && theName.length() > 0)
420             setName(theName);
421
422         if(theSeverityLevel >= 0)
423             setSeverityLevel(theSeverityLevel);
424         else
425         {
426             String JavaDoc sl = System.getProperty("ForteReporterDebugLevel");//NOI18N
427 if(sl != null && sl.length() > 0)
428             {
429                 int sli = Integer.parseInt(sl);
430                 setSeverityLevel(sli);
431             }
432         }
433
434         className = getClass().getName();
435         writer = new ReporterWriter(getName());
436
437         debug("Ctor called");//NOI18N
438 debug("ReporterImpl Severity Level: " + getSeverityLevel());//NOI18N
439 }
440     
441     ///////////////////////////////////////////////////////////////////////////////////////////////////////
442
443     private boolean checkSeverity(int severity)
444     {
445         if(severity >= severityLevel)
446             return true;
447
448         return false;
449     }
450     
451     ///////////////////////////////////////////////////////////////////////////////////////////////////////
452
453     private CallerInfo getCallerInfo()
454     {
455         try
456         {
457             return new CallerInfo(new Object JavaDoc[] { this });
458         }
459         catch(CallerInfoException e)
460         {
461             debug(e.toString());
462             return null;
463         }
464     }
465     
466     ///////////////////////////////////////////////////////////////////////////////////////////////////////
467
468     private void pr(int severity, Object JavaDoc o)
469     {
470         try
471         {
472             CallerInfo ci = getCallerInfo();
473             
474             String JavaDoc s;
475
476             if(o == null)
477             {
478                 s = "null Object argument";//NOI18N
479 }
480             else
481             {
482                 s = o.toString();
483
484                 if(s == null) // || s.length() <= 0)
485 s = "null toString result from Object";//NOI18N
486 }
487
488
489             if(ci != null)
490                 s = ci.toString() + ": " + s;//NOI18N
491
492             writer.println(severity, s);
493         }
494         catch(Throwable JavaDoc e)
495         {
496             System.out.println("Got exception in ReporterImpl.pr(): " + e);//NOI18N
497 }
498     }
499     
500     ///////////////////////////////////////////////////////////////////////////////////////////////////////
501
502     private String JavaDoc getClassName()
503     {
504         Assertion.check(className);
505         return className;
506     }
507     
508     ///////////////////////////////////////////////////////////////////////////////////////////////////////
509
510     private int calcSeverityLevel(String JavaDoc original)
511     {
512         if(original == null || original.length() <= 0)
513             return DISABLED;
514
515         String JavaDoc s = original.toUpperCase();
516
517         // first let's see if it is an integer...
518
519         try
520         {
521             int ret = Integer.parseInt(s);
522
523             if(ret < 0)
524                 ret = 0;
525
526             return ret;
527         }
528         catch(NumberFormatException JavaDoc e)
529         {
530         }
531
532         // not a number -- let's check a few more possibilities...
533
534         if(s.equals("ALL") || s.equals("NOISY") || s.equals("EVERYTHING") || s.equals("ON") //NOI18N
535 || s.equals("MONDO") || s.equals("YES") || s.equals("TRUE") || s.equals("DUMP") || s.startsWith("MAX"))//NOI18N
536 return 0;
537         if(s.startsWith("NO") || s.equals("OFF") || s.equals("FALSE") || s.equals("QUIET") || s.startsWith("MIN"))//NOI18N
538 return DISABLED;
539
540         // it should be "WARN", "CRITICAL", etc.
541 // since all of the values start with a different character,
542 // just check the first character...
543 char first = s.charAt(0); // uppercase!!
544
545         for(int i = 0; i < severityNames.length; i++)
546         {
547             if(severityNames[i].toUpperCase().charAt(0) == first)
548                 return i;
549         }
550
551         // I give up!
552 debug("Unknown value for commandline argument \"-DIABDebug=" + original + "\"");//NOI18N
553 return DISABLED;
554     }
555
556     private void debug(String JavaDoc s)
557     {
558         if(doDebug)
559             System.out.println("ReporterImpl Report --> " + s);//NOI18N
560 }
561     
562     ///////////////////////////////////////////////////////////////////////////////////////////////////////
563
564     private int severityLevel = DISABLED;
565     private String JavaDoc name = "Main";//NOI18N
566 private ReporterWriter writer;
567     private String JavaDoc className;
568     private static final boolean doDebug = false;
569 }
570
571
Popular Tags