1 /*
2 * Copyright (c) 2009, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.javafx.logging;
27
28 import java.lang.ref.WeakReference;
29 import java.util.HashMap;
30 import java.util.Map;
31 import java.util.ResourceBundle;
32
33 /**
34 * Platform logger provides an API for the JavaFX components to log
35 * messages. It is an internal logger intended to be used by JavaFX modules.
36 *
37 * The PlatformLogger uses an underlying System.Logger
38 * obtained by calling {@link java.lang.System.Logger#getLogger(String)}
39 *
40 * PlatformLogger implements System.Logger as to facilitiate logging of
41 * calling class and method.
42 * Note : JDK internal loggers know to skip any calls from System.Logger
43 * classes when looking for the calling class / method.
44 */
45 public class PlatformLogger implements System.Logger {
46
47 /**
48 * PlatformLogger logging levels.
49 */
50 public static enum Level {
51 // The name and value must match that of {@code java.lang.System.Level}s.
52 // Declare in ascending order of the given value
53 ALL(System.Logger.Level.ALL),
54 FINEST(System.Logger.Level.TRACE),
55 FINER(System.Logger.Level.TRACE),
56 FINE(System.Logger.Level.DEBUG),
57 INFO(System.Logger.Level.INFO),
58 WARNING(System.Logger.Level.WARNING),
59 SEVERE(System.Logger.Level.ERROR),
60 OFF(System.Logger.Level.OFF);
61
62 final System.Logger.Level systemLevel;
63 Level(System.Logger.Level systemLevel) {
64 this.systemLevel = systemLevel;
65 }
66 }
67
68 private System.Logger.Level getSystemLoggerLevel(Level l) {
69 switch (l) {
70 case ALL : return System.Logger.Level.ALL;
71 case FINEST: return System.Logger.Level.TRACE;
72 case FINER: return System.Logger.Level.TRACE;
73 case FINE: return System.Logger.Level.DEBUG;
74 case INFO: return System.Logger.Level.INFO;
75 case WARNING: return System.Logger.Level.WARNING;
76 case SEVERE: return System.Logger.Level.ERROR;
77 case OFF: return System.Logger.Level.OFF;
78 default : return System.Logger.Level.ALL;
79 }
80 }
81
82
83 // Table of known loggers. Maps names to PlatformLoggers.
84 private static final Map<String,WeakReference<PlatformLogger>> loggers =
85 new HashMap<>();
86
87 /**
88 * Returns a PlatformLogger of a given name.
89 * @param name the name of the logger
90 * @return a PlatformLogger
91 */
92 public static synchronized PlatformLogger getLogger(String name) {
93 PlatformLogger log = null;
94 WeakReference<PlatformLogger> ref = loggers.get(name);
95 if (ref != null) {
96 log = ref.get();
97 }
98 if (log == null) {
99 log = new PlatformLogger(System.getLogger(name));
100 loggers.put(name, new WeakReference<>(log));
101 }
102 return log;
103 }
104
105
106 private final System.Logger loggerProxy;
107 protected PlatformLogger(System.Logger loggerProxy) {
108 this.loggerProxy = loggerProxy;
109 }
110
111 // ------------------------------------------------------------------------
112 // From System.Logger interface
113 // ------------------------------------------------------------------------
114
115 /**
116 * Gets the name for this platform logger.
117 * @return the name of the platform logger.
118 */
119 @Override
120 public String getName() {
121 throw new UnsupportedOperationException("not implemented");
122 }
123
124 @Override
125 public boolean isLoggable(System.Logger.Level level) {
126 throw new UnsupportedOperationException("not implemented");
127 }
128
129 @Override
130 public void log(System.Logger.Level level, ResourceBundle bundle, String format, Object... params) {
131 throw new UnsupportedOperationException("not implemented");
132 }
133
134 @Override
135 public void log(System.Logger.Level level, ResourceBundle bundle, String msg, Throwable thrown) {
136 throw new UnsupportedOperationException("not implemented");
137 }
138
139 // ------------------------------------------------------------------------
140
141
142 /**
143 * Returns true if a message of the given level would actually
144 * be logged by this logger.
145 * @param level the level
146 * @return whether a message of that level would be logged
147 */
148 public boolean isLoggable(Level level) {
149 if (level == null) {
150 throw new NullPointerException();
151 }
152
153 return loggerProxy.isLoggable(getSystemLoggerLevel(level));
154 }
155
156 /**
157 * Logs a SEVERE message.
158 * @param msg the message
159 */
160 public void severe(String msg) {
161 if (!loggingEnabled) return;
162 loggerProxy.log(System.Logger.Level.ERROR, msg, (Object[])null);
163 }
164
165 public void severe(String msg, Throwable t) {
166 if (!loggingEnabled) return;
167 loggerProxy.log(System.Logger.Level.ERROR, msg, t);
168 }
169
170 public void severe(String msg, Object... params) {
171 if (!loggingEnabled) return;
172 loggerProxy.log(System.Logger.Level.ERROR, msg, params);
173 }
174
175 /**
176 * Logs a WARNING message.
177 * @param msg the message
178 */
179 public void warning(String msg) {
180 if (!loggingEnabled) return;
181 loggerProxy.log(System.Logger.Level.WARNING, msg, (Object[])null);
182 }
183
184 public void warning(String msg, Throwable t) {
185 if (!loggingEnabled) return;
186 loggerProxy.log(System.Logger.Level.WARNING, msg, t);
187 }
188
189 public void warning(String msg, Object... params) {
190 if (!loggingEnabled) return;
191 loggerProxy.log(System.Logger.Level.WARNING, msg, params);
192 }
193
194 /**
195 * Logs an INFO message.
196 * @param msg the message
197 */
198 public void info(String msg) {
199 if (!loggingEnabled) return;
200 loggerProxy.log(System.Logger.Level.INFO, msg, (Object[])null);
201 }
202
203 public void info(String msg, Throwable t) {
204 if (!loggingEnabled) return;
205 loggerProxy.log(System.Logger.Level.INFO, msg, t);
206 }
207
208 public void info(String msg, Object... params) {
209 if (!loggingEnabled) return;
210 loggerProxy.log(System.Logger.Level.INFO, msg, params);
211 }
212
213 /**
214 * Logs a FINE message.
215 * @param msg the message
216 */
217 public void fine(String msg) {
218 if (!loggingEnabled) return;
219 loggerProxy.log(System.Logger.Level.DEBUG, msg, (Object[])null);
220 }
221
222 public void fine(String msg, Throwable t) {
223 if (!loggingEnabled) return;
224 loggerProxy.log(System.Logger.Level.DEBUG, msg, t);
225 }
226
227 public void fine(String msg, Object... params) {
228 if (!loggingEnabled) return;
229 loggerProxy.log(System.Logger.Level.DEBUG, msg, params);
230 }
231
232 /**
233 * Logs a FINER message.
234 * @param msg the message
235 */
236 public void finer(String msg) {
237 if (!loggingEnabled) return;
238 loggerProxy.log(System.Logger.Level.TRACE, msg, (Object[])null);
239 }
240
241 public void finer(String msg, Throwable t) {
242 if (!loggingEnabled) return;
243 loggerProxy.log(System.Logger.Level.TRACE, msg, t);
244 }
245
246 public void finer(String msg, Object... params) {
247 if (!loggingEnabled) return;
248 loggerProxy.log(System.Logger.Level.TRACE, msg, params);
249 }
250
251 /**
252 * Logs a FINEST message.
253 * @param msg the message
254 */
255 public void finest(String msg) {
256 if (!loggingEnabled) return;
257 loggerProxy.log(System.Logger.Level.TRACE, msg, (Object[])null);
258 }
259
260 public void finest(String msg, Throwable t) {
261 if (!loggingEnabled) return;
262 loggerProxy.log(System.Logger.Level.TRACE, msg, t);
263 }
264
265 public void finest(String msg, Object... params) {
266 if (!loggingEnabled) return;
267 loggerProxy.log(System.Logger.Level.TRACE, msg, params);
268 }
269
270 // Methods for unit tests
271 private boolean loggingEnabled = true;
272 public void enableLogging() {
273 loggingEnabled = true;
274 };
275
276 public void disableLogging() {
277 loggingEnabled = false;
278 }
279 }
280