KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > avalon > framework > logger > Jdk14Logger


1 /* ====================================================================
2  * The Apache Software License, Version 1.1
3  *
4  * Copyright (c) 1997-2003 The Apache Software Foundation. All rights
5  * reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  * notice, this list of conditions and the following disclaimer in
16  * the documentation and/or other materials provided with the
17  * distribution.
18  *
19  * 3. The end-user documentation included with the redistribution,
20  * if any, must include the following acknowledgment:
21  * "This product includes software developed by the
22  * Apache Software Foundation (http://www.apache.org/)."
23  * Alternately, this acknowledgment may appear in the software
24  * itself, if and wherever such third-party acknowledgments
25  * normally appear.
26  *
27  * 4. The names "Jakarta", "Avalon", and "Apache Software Foundation"
28  * must not be used to endorse or promote products derived from this
29  * software without prior written permission. For written
30  * permission, please contact apache@apache.org.
31  *
32  * 5. Products derived from this software may not be called "Apache",
33  * nor may "Apache" appear in their name, without prior written
34  * permission of the Apache Software Foundation.
35  *
36  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39  * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47  * SUCH DAMAGE.
48  * ====================================================================
49  *
50  * This software consists of voluntary contributions made by many
51  * individuals on behalf of the Apache Software Foundation. For more
52  * information on the Apache Software Foundation, please see
53  * <http://www.apache.org/>.
54  */
55 package org.apache.avalon.framework.logger;
56
57 import java.util.logging.Level JavaDoc;
58
59 /**
60  * The default JDK 1.4 wrapper class for Logger. Please note that there is
61  * not an exact match to the priority levels that JDK 1.4 logging has and
62  * what LogKit or Log4J has. For that reason, the following priority level
63  * matching was used:
64  *
65  * <ul>
66  * <li>SEVERE = error, fatalError</li>
67  * <li>WARNING = warn</li>
68  * <li>INFO = info</li>
69  * <li>FINE = debug</li>
70  * </ul>
71  *
72  * <p>
73  * JDK 1.4 does allow you to have other levels like: CONFIG, FINER, and
74  * FINEST. Most projects don't separate out configuration logging from
75  * debugging information. Also, we wanted to maintain backwards
76  * compatibility as much as possible. Unfortunately, with all the "fineness"
77  * details, there is no equivalent to the "error" log level.
78  * </p>
79  *
80  * @author <a HREF="mailto:dev@avalon.apache.org">Avalon Development Team</a>
81  * @version CVS $Revision: 1.16 $ $Date: 2003/02/11 15:58:41 $
82  */
83 public final class Jdk14Logger
84     implements Logger
85 {
86     //The actual JDK1.4 logger implementation
87 private final java.util.logging.Logger JavaDoc m_logger;
88
89     /**
90      * Construct a Logger with specified jdk1.4 logger instance as implementation.
91      *
92      * @param logImpl the jdk1.4 logger instance to delegate to
93      */
94     public Jdk14Logger( java.util.logging.Logger JavaDoc logImpl )
95     {
96         m_logger = logImpl;
97     }
98
99     /**
100      * Log a debug message.
101      *
102      * @param message the message
103      */
104     public final void debug( final String JavaDoc message )
105     {
106         m_logger.log( Level.FINE, message );
107     }
108
109     /**
110      * Log a debug message.
111      *
112      * @param message the message
113      * @param throwable the throwable
114      */
115     public final void debug( final String JavaDoc message, final Throwable JavaDoc throwable )
116     {
117         m_logger.log( Level.FINE, message, throwable );
118     }
119
120     /**
121      * Determine if messages of priority "debug" will be logged.
122      *
123      * @return true if "debug" messages will be logged
124      */
125     public final boolean isDebugEnabled()
126     {
127         return m_logger.isLoggable( Level.FINE );
128     }
129
130     /**
131      * Log a info message.
132      *
133      * @param message the message
134      */
135     public final void info( final String JavaDoc message )
136     {
137         m_logger.log( Level.INFO, message );
138     }
139
140     /**
141      * Log a info message.
142      *
143      * @param message the message
144      * @param throwable the throwable
145      */
146     public final void info( final String JavaDoc message, final Throwable JavaDoc throwable )
147     {
148         m_logger.log( Level.INFO, message, throwable );
149     }
150
151     /**
152      * Determine if messages of priority "info" will be logged.
153      *
154      * @return true if "info" messages will be logged
155      */
156     public final boolean isInfoEnabled()
157     {
158         return m_logger.isLoggable( Level.INFO );
159     }
160
161     /**
162      * Log a warn message.
163      *
164      * @param message the message
165      */
166     public final void warn( final String JavaDoc message )
167     {
168         m_logger.log( Level.WARNING, message );
169     }
170
171     /**
172      * Log a warn message.
173      *
174      * @param message the message
175      * @param throwable the throwable
176      */
177     public final void warn( final String JavaDoc message, final Throwable JavaDoc throwable )
178     {
179         m_logger.log( Level.WARNING, message, throwable );
180     }
181
182     /**
183      * Determine if messages of priority "warn" will be logged.
184      *
185      * @return true if "warn" messages will be logged
186      */
187     public final boolean isWarnEnabled()
188     {
189         return m_logger.isLoggable( Level.WARNING );
190     }
191
192     /**
193      * Log a error message.
194      *
195      * @param message the message
196      */
197     public final void error( final String JavaDoc message )
198     {
199         m_logger.log( Level.SEVERE, message );
200     }
201
202     /**
203      * Log a error message.
204      *
205      * @param message the message
206      * @param throwable the throwable
207      */
208     public final void error( final String JavaDoc message, final Throwable JavaDoc throwable )
209     {
210         m_logger.log( Level.SEVERE, message, throwable );
211     }
212
213     /**
214      * Determine if messages of priority "error" will be logged.
215      *
216      * @return true if "error" messages will be logged
217      */
218     public final boolean isErrorEnabled()
219     {
220         return m_logger.isLoggable( Level.SEVERE );
221     }
222
223     /**
224      * Log a fatalError message.
225      *
226      * @param message the message
227      */
228     public final void fatalError( final String JavaDoc message )
229     {
230         m_logger.log( Level.SEVERE, message );
231     }
232
233     /**
234      * Log a fatalError message.
235      *
236      * @param message the message
237      * @param throwable the throwable
238      */
239     public final void fatalError( final String JavaDoc message, final Throwable JavaDoc throwable )
240     {
241         m_logger.log( Level.SEVERE, message, throwable );
242     }
243
244     /**
245      * Determine if messages of priority "fatalError" will be logged.
246      *
247      * @return true if "fatalError" messages will be logged
248      */
249     public final boolean isFatalErrorEnabled()
250     {
251         return m_logger.isLoggable( Level.SEVERE );
252     }
253
254     /**
255      * Create a new child logger.
256      * The name of the child logger is [current-loggers-name].[passed-in-name]
257      * Throws <code>IllegalArgumentException</code> if name has an empty element name
258      *
259      * @param name the subname of this logger
260      * @return the new logger
261      */
262     public final Logger getChildLogger( final String JavaDoc name )
263     {
264         return new Jdk14Logger( java.util.logging.Logger
265                                 .getLogger( m_logger.getName() + "." + name ) );
266     }
267 }
268
Popular Tags