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.Arrays;
30 import java.util.HashMap;
31 import java.util.Map;
32 import java.util.ResourceBundle;
33
34 /**
35 * Platform logger provides an API for the JavaFX components to log
36 * messages. It is an internal logger intended to be used by JavaFX modules.
37 *
38 * The PlatformLogger uses an underlying System.Logger
39 * obtained by calling {@link java.lang.System.Logger#getLogger(String)}
40 *
41 * PlatformLogger implements System.Logger as to facilitiate logging of
42 * calling class and method.
43 * Note : JDK internal loggers know to skip any calls from System.Logger
44 * classes when looking for the calling class / method.
45 */
46 public class PlatformLogger implements System.Logger {
47
48 /**
49 * PlatformLogger logging levels.
50 */
51 public static enum Level {
52 // The name and value must match that of {@code java.lang.System.Level}s.
53 // Declare in ascending order of the given value
54 ALL(System.Logger.Level.ALL),
55 FINEST(System.Logger.Level.TRACE),
56 FINER(System.Logger.Level.TRACE),
57 FINE(System.Logger.Level.DEBUG),
58 INFO(System.Logger.Level.INFO),
59 WARNING(System.Logger.Level.WARNING),
60 SEVERE(System.Logger.Level.ERROR),
61 OFF(System.Logger.Level.OFF);
62
63 final System.Logger.Level systemLevel;
64 Level(System.Logger.Level systemLevel) {
65 this.systemLevel = systemLevel;
66 }
67 }
68
69 private System.Logger.Level getSystemLoggerLevel(Level l) {
70 switch (l) {
71 case ALL : return System.Logger.Level.ALL;
72 case FINEST: return System.Logger.Level.TRACE;
73 case FINER: return System.Logger.Level.TRACE;
74 case FINE: return System.Logger.Level.DEBUG;
75 case INFO: return System.Logger.Level.INFO;
76 case WARNING: return System.Logger.Level.WARNING;
77 case SEVERE: return System.Logger.Level.ERROR;
78 case OFF: return System.Logger.Level.OFF;
79 default : return System.Logger.Level.ALL;
80 }
81 }
82
83
84 // Table of known loggers. Maps names to PlatformLoggers.
85 private static final Map<String,WeakReference<PlatformLogger>> loggers =
86 new HashMap<>();
87
88 /**
89 * Returns a PlatformLogger of a given name.
90 * @param name the name of the logger
91 * @return a PlatformLogger
92 */
93 public static synchronized PlatformLogger getLogger(String name) {
94 PlatformLogger log = null;
95 WeakReference<PlatformLogger> ref = loggers.get(name);
96 if (ref != null) {
97 log = ref.get();
98 }
99 if (log == null) {
100 log = new PlatformLogger(System.getLogger(name));
101 loggers.put(name, new WeakReference<>(log));
102 }
103 return log;
104 }
105
106
107 private final System.Logger loggerProxy;
108 private PlatformLogger(System.Logger loggerProxy) {
109 this.loggerProxy = loggerProxy;
110 }
111
112 // ------------------------------------------------------------------------
113 // From System.Logger interface
114 // ------------------------------------------------------------------------
115
116 /**
117 * Gets the name for this platform logger.
118 * @return the name of the platform logger.
119 */
120 @Override
121 public String getName() {
122 throw new UnsupportedOperationException("not implemented");
123 }
124
125 @Override
126 public boolean isLoggable(System.Logger.Level level) {
127 throw new UnsupportedOperationException("not implemented");
128 }
129
130 @Override
131 public void log(System.Logger.Level level, ResourceBundle bundle, String format, Object... params) {
132 throw new UnsupportedOperationException("not implemented");
133 }
134
135 @Override
136 public void log(System.Logger.Level level, ResourceBundle bundle, String msg, Throwable thrown) {
137 throw new UnsupportedOperationException("not implemented");
138 }
139
140 // ------------------------------------------------------------------------
141
142
143 /**
144 * Returns true if a message of the given level would actually
145 * be logged by this logger.
146 * @param level the level
147 * @return whether a message of that level would be logged
148 */
149 public boolean isLoggable(Level level) {
150 if (level == null) {
151 throw new NullPointerException();
152 }
153
154 return loggerProxy.isLoggable(getSystemLoggerLevel(level));
155 }
156
157 /**
158 * Logs a SEVERE message.
159 * @param msg the message
160 */
161 public void severe(String msg) {
162 if (!loggingEnabled) return;
163 loggerProxy.log(System.Logger.Level.ERROR, msg, (Object[])null);
164 }
165
166 public void severe(String msg, Throwable t) {
167 if (!loggingEnabled) return;
168 loggerProxy.log(System.Logger.Level.ERROR, msg, t);
169 }
170
171 public void severe(String msg, Object... params) {
172 if (!loggingEnabled) return;
173 loggerProxy.log(System.Logger.Level.ERROR, msg, params);
174 }
175
176 /**
177 * Logs a WARNING message.
178 * @param msg the message
179 */
180 public void warning(String msg) {
181 if (!loggingEnabled) return;
182 loggerProxy.log(System.Logger.Level.WARNING, msg, (Object[])null);
183 }
184
185 public void warning(String msg, Throwable t) {
186 if (!loggingEnabled) return;
187 loggerProxy.log(System.Logger.Level.WARNING, msg, t);
188 }
189
190 public void warning(String msg, Object... params) {
191 if (!loggingEnabled) return;
192 loggerProxy.log(System.Logger.Level.WARNING, msg, params);
193 }
194
195 /**
196 * Logs an INFO message.
197 * @param msg the message
198 */
199 public void info(String msg) {
200 if (!loggingEnabled) return;
201 loggerProxy.log(System.Logger.Level.INFO, msg, (Object[])null);
202 }
203
204 public void info(String msg, Throwable t) {
205 if (!loggingEnabled) return;
206 loggerProxy.log(System.Logger.Level.INFO, msg, t);
207 }
208
209 public void info(String msg, Object... params) {
210 if (!loggingEnabled) return;
211 loggerProxy.log(System.Logger.Level.INFO, msg, params);
212 }
213
214 /**
215 * Logs a FINE message.
216 * @param msg the message
217 */
218 public void fine(String msg) {
219 if (!loggingEnabled) return;
220 loggerProxy.log(System.Logger.Level.DEBUG, msg, (Object[])null);
221 }
222
223 public void fine(String msg, Throwable t) {
224 if (!loggingEnabled) return;
225 loggerProxy.log(System.Logger.Level.DEBUG, msg, t);
226 }
227
228 public void fine(String msg, Object... params) {
229 if (!loggingEnabled) return;
230 loggerProxy.log(System.Logger.Level.DEBUG, msg, params);
231 }
232
233 /**
234 * Logs a FINER message.
235 * @param msg the message
236 */
237 public void finer(String msg) {
238 if (!loggingEnabled) return;
239 loggerProxy.log(System.Logger.Level.TRACE, msg, (Object[])null);
240 }
241
242 public void finer(String msg, Throwable t) {
243 if (!loggingEnabled) return;
244 loggerProxy.log(System.Logger.Level.TRACE, msg, t);
245 }
246
247 public void finer(String msg, Object... params) {
248 if (!loggingEnabled) return;
249 loggerProxy.log(System.Logger.Level.TRACE, msg, params);
250 }
251
252 /**
253 * Logs a FINEST message.
254 * @param msg the message
255 */
256 public void finest(String msg) {
257 if (!loggingEnabled) return;
258 loggerProxy.log(System.Logger.Level.TRACE, msg, (Object[])null);
259 }
260
261 public void finest(String msg, Throwable t) {
262 if (!loggingEnabled) return;
263 loggerProxy.log(System.Logger.Level.TRACE, msg, t);
264 }
265
266 public void finest(String msg, Object... params) {
267 if (!loggingEnabled) return;
268 loggerProxy.log(System.Logger.Level.TRACE, msg, params);
269 }
270
271 // Methods for unit tests
272 private boolean loggingEnabled = true;
273 public void enableLogging() {
274 loggingEnabled = true;
275 };
276
277 public void disableLogging() {
278 loggingEnabled = false;
279 }
280 }
281