KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > grlea > logBridge > impl > LoggingToolkitLogBridgeFactory


1 package org.grlea.logBridge.impl;
2
3 // $Id: LoggingToolkitLogBridgeFactory.java,v 1.1 2005/03/02 10:46:03 grlea Exp $
4 // Copyright (c) 2004 Graham Lea. All rights reserved.
5
6 // Licensed under the Apache License, Version 2.0 (the "License");
7 // you may not use this file except in compliance with the License.
8 // You may obtain a copy of the License at
9 //
10 // http://www.apache.org/licenses/LICENSE-2.0
11 //
12 // Unless required by applicable law or agreed to in writing, software
13 // distributed under the License is distributed on an "AS IS" BASIS,
14 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 // See the License for the specific language governing permissions and
16 // limitations under the License.
17
18 import org.grlea.logBridge.LogBridge;
19 import org.grlea.logBridge.LogBridgeFactory;
20
21 import com.ibm.logging.IRecordType;
22 import com.ibm.logging.Logger;
23
24 /**
25  * <p>A {@link LogBridgeFactory} implementation for
26  * <a HREF="http://www.alphaworks.ibm.com/tech/loggingtoolkit4j" target="_blank">
27  * IBM's Logging Toolkit for Java</a>.</p>
28  *
29  * <p>Log Bridge levels convert to Logging Toolkit's flags as follows:
30  * <table>
31  * <tr><th>Log Bridge</th> <th>Log4j Level</th></tr>
32  * <tr><td>Error</td> <td>{@link IRecordType#TYPE_ERROR}</td></tr>
33  * <tr><td>Warning</td> <td>{@link IRecordType#TYPE_WARN}</td></tr>
34  * <tr><td>Info</td> <td>{@link IRecordType#TYPE_INFO}</td></tr>
35  * <tr><td>Debug</td> <td>{@link IRecordType#TYPE_DEBUG_MIN}</td></tr>
36  * <tr><td>Verbose</td> <td>{@link IRecordType#TYPE_DEBUG_MID}</td></tr>
37  * <tr><td>Tracing</td> <td>{@link IRecordType#TYPE_DEBUG_MAX}
38  * (+ {@link IRecordType#TYPE_DEFAULT_TRACE})</td></tr>
39  * </table>
40  * </p>
41  *
42  * @author grlea
43  * @version $Revision: 1.1 $
44  */
45 public class
46 LoggingToolkitLogBridgeFactory
47 implements LogBridgeFactory
48 {
49    public
50    LoggingToolkitLogBridgeFactory()
51    {
52    }
53
54    public LogBridge
55    getLogBridge(Class JavaDoc sourceClass)
56    {
57       return new Bridge(new Logger(sourceClass.getName()));
58    }
59
60    private static final class
61    Bridge
62    implements LogBridge
63    {
64       private static final long ERROR = IRecordType.TYPE_ERROR;
65       private static final long WARN = IRecordType.TYPE_WARN;
66       private static final long INFO = IRecordType.TYPE_INFO;
67       private static final long DEBUG = IRecordType.TYPE_DEBUG_MIN;
68       private static final long VERBOSE = IRecordType.TYPE_DEBUG_MID;
69       private static final long TRACE = IRecordType.TYPE_DEBUG_MAX;
70
71       private final Logger logger;
72
73       private final String JavaDoc loggingClass;
74
75       public
76       Bridge(Logger logger)
77       {
78          this.logger = logger;
79          loggingClass = logger.getName();
80       }
81
82       public boolean
83       isErrorEnabled()
84       {
85          return logger.isLogging;
86       }
87
88       public boolean
89       isWarnEnabled()
90       {
91          return logger.isLogging;
92       }
93
94       public boolean
95       isInfoEnabled()
96       {
97          return logger.isLogging;
98       }
99
100       public boolean
101       isDebugEnabled()
102       {
103          return logger.isLogging;
104       }
105
106       public boolean
107       isVerboseEnabled()
108       {
109          return logger.isLogging;
110       }
111
112       public boolean
113       isTracingEnabled()
114       {
115          return logger.isLogging;
116       }
117
118       public void
119       error(String JavaDoc message)
120       {
121          logger.text(ERROR, loggingClass, "", message);
122       }
123
124       public void
125       error(String JavaDoc objectName, Object JavaDoc value)
126       {
127          if (isErrorEnabled())
128             logger.text(ERROR, loggingClass, "", objectName + ": " + value);
129       }
130
131       public void
132       error(Throwable JavaDoc error)
133       {
134          logger.exception(ERROR, loggingClass, "", error);
135       }
136
137       public void
138       warn(String JavaDoc message)
139       {
140          logger.text(WARN, loggingClass, "", message);
141       }
142
143       public void
144       warn(String JavaDoc objectName, Object JavaDoc value)
145       {
146          if (isWarnEnabled())
147             logger.text(WARN, loggingClass, "", objectName + ": " + value);
148       }
149
150       public void
151       warn(Throwable JavaDoc error)
152       {
153          logger.exception(WARN, loggingClass, "", error);
154       }
155
156       public void
157       info(String JavaDoc message)
158       {
159          logger.text(INFO, loggingClass, "", message);
160       }
161
162       public void
163       info(String JavaDoc objectName, Object JavaDoc value)
164       {
165          if (isInfoEnabled())
166             logger.text(INFO, loggingClass, "", objectName + ": " + value);
167       }
168
169       public void
170       info(Throwable JavaDoc error)
171       {
172          logger.exception(INFO, loggingClass, "", error);
173       }
174
175       public void
176       debug(String JavaDoc message)
177       {
178          logger.text(DEBUG, loggingClass, "", message);
179       }
180
181       public void
182       debug(String JavaDoc objectName, Object JavaDoc value)
183       {
184          if (isDebugEnabled())
185             logger.text(DEBUG, loggingClass, "", objectName + ": " + value);
186       }
187
188       public void
189       debug(Throwable JavaDoc error)
190       {
191          logger.exception(DEBUG, loggingClass, "", error);
192       }
193
194       public void
195       verbose(String JavaDoc message)
196       {
197          logger.text(VERBOSE, loggingClass, "", message);
198       }
199
200       public void
201       verbose(String JavaDoc objectName, Object JavaDoc value)
202       {
203          if (isVerboseEnabled())
204             logger.text(VERBOSE, loggingClass, "", objectName + ": " + value);
205       }
206
207       public void
208       verbose(Throwable JavaDoc error)
209       {
210          logger.exception(VERBOSE, loggingClass, "", error);
211       }
212
213       public void
214       entry(String JavaDoc methodName)
215       {
216          logger.entry(TRACE, loggingClass, methodName);
217       }
218
219       public void
220       exit(String JavaDoc methodName)
221       {
222          logger.exit(TRACE, loggingClass, methodName);
223       }
224    }
225 }
Popular Tags