KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > dna > impl > LogkitLogger


1 /*
2  * Copyright (C) The DNA Group. All rights reserved.
3  *
4  * This software is published under the terms of the DNA
5  * Software License version 1.1, a copy of which has been included
6  * with this distribution in the LICENSE.txt file.
7  */
8 package org.codehaus.dna.impl;
9
10 import org.codehaus.dna.Logger;
11
12 /**
13  * Logging facade implmentation for Apache Logkit project.
14  * The following lists the mapping between DNA log levels
15  * and LogKit log levels.
16  *
17  * <ul>
18  * <li>trace ==&gt; debug</li>
19  * <li>debug ==&gt; debug</li>
20  * <li>info ==&gt; info</li>
21  * <li>warn ==&gt; warn</li>
22  * <li>error ==&gt; error</li>
23  * </ul>
24  *
25  * @version $Revision: 1.2 $ $Date: 2004/05/01 09:51:48 $
26  */
27 public class LogkitLogger
28     implements Logger
29 {
30     /**
31      * The Logkit logger.
32      */
33     private final org.apache.log.Logger m_logger;
34
35     /**
36      * Create an instance of LogKit logger facade.
37      *
38      * @param logger the logkit logger
39      */
40     public LogkitLogger( final org.apache.log.Logger logger )
41     {
42         if( null == logger )
43         {
44             throw new NullPointerException JavaDoc( "logger" );
45         }
46         m_logger = logger;
47     }
48
49     /**
50      * Log a trace message.
51      *
52      * @param message the message
53      */
54     public void trace( final String JavaDoc message )
55     {
56         m_logger.debug( message );
57     }
58
59     /**
60      * Log a trace message with an associated throwable.
61      *
62      * @param message the message
63      * @param throwable the throwable
64      */
65     public void trace( final String JavaDoc message,
66                        final Throwable JavaDoc throwable )
67     {
68         m_logger.debug( message, throwable );
69     }
70
71     /**
72      * Return true if a trace message will be logged.
73      *
74      * @return true if message will be logged
75      */
76     public boolean isTraceEnabled()
77     {
78         return m_logger.isDebugEnabled();
79     }
80
81     /**
82      * Log a debug message.
83      *
84      * @param message the message
85      */
86     public void debug( final String JavaDoc message )
87     {
88         m_logger.debug( message );
89     }
90
91     /**
92      * Log a debug message with an associated throwable.
93      *
94      * @param message the message
95      * @param throwable the throwable
96      */
97     public void debug( final String JavaDoc message,
98                        final Throwable JavaDoc throwable )
99     {
100         m_logger.debug( message, throwable );
101     }
102
103     /**
104      * Return true if a debug message will be logged.
105      *
106      * @return true if message will be logged
107      */
108     public boolean isDebugEnabled()
109     {
110         return m_logger.isDebugEnabled();
111     }
112
113     /**
114      * Log a info message.
115      *
116      * @param message the message
117      */
118     public void info( final String JavaDoc message )
119     {
120         m_logger.info( message );
121     }
122
123     /**
124      * Log a info message with an associated throwable.
125      *
126      * @param message the message
127      * @param throwable the throwable
128      */
129     public void info( final String JavaDoc message,
130                       final Throwable JavaDoc throwable )
131     {
132         m_logger.info( message, throwable );
133     }
134
135     /**
136      * Return true if an info message will be logged.
137      *
138      * @return true if message will be logged
139      */
140     public boolean isInfoEnabled()
141     {
142         return m_logger.isInfoEnabled();
143     }
144
145     /**
146      * Log a warn message.
147      *
148      * @param message the message
149      */
150     public void warn( final String JavaDoc message )
151     {
152         m_logger.warn( message );
153     }
154
155     /**
156      * Log a warn message with an associated throwable.
157      *
158      * @param message the message
159      * @param throwable the throwable
160      */
161     public void warn( final String JavaDoc message,
162                       final Throwable JavaDoc throwable )
163     {
164         m_logger.warn( message, throwable );
165     }
166
167     /**
168      * Return true if a warn message will be logged.
169      *
170      * @return true if message will be logged
171      */
172     public boolean isWarnEnabled()
173     {
174         return m_logger.isWarnEnabled();
175     }
176
177     /**
178      * Log a error message.
179      *
180      * @param message the message
181      */
182     public void error( final String JavaDoc message )
183     {
184         m_logger.error( message );
185     }
186
187     /**
188      * Log a error message with an associated throwable.
189      *
190      * @param message the message
191      * @param throwable the throwable
192      */
193     public void error( final String JavaDoc message,
194                        final Throwable JavaDoc throwable )
195     {
196         m_logger.error( message, throwable );
197     }
198
199     /**
200      * Return true if a error message will be logged.
201      *
202      * @return true if message will be logged
203      */
204     public boolean isErrorEnabled()
205     {
206         return m_logger.isErrorEnabled();
207     }
208
209     /**
210      * Get the child logger with specified name.
211      *
212      * @param name the name of child logger
213      * @return the child logger
214      */
215     public Logger getChildLogger( final String JavaDoc name )
216     {
217         return new LogkitLogger( m_logger.getChildLogger( name ) );
218     }
219 }
220
Popular Tags