153 * provide its own implementation of named Loggers for any point in
154 * the namespace. Therefore, any subclasses of Logger (unless they
155 * are implemented in conjunction with a new LogManager class) should
156 * take care to obtain a Logger instance from the LogManager class and
157 * should delegate operations such as "isLoggable" and "log(LogRecord)"
158 * to that instance. Note that in order to intercept all logging
159 * output, subclasses need only override the log(LogRecord) method.
160 * All the other logging methods are implemented as calls on this
161 * log(LogRecord) method.
162 *
163 * @since 1.4
164 */
165
166
167 public class Logger {
168 private static final Handler emptyHandlers[] = new Handler[0];
169 private static final int offValue = Level.OFF.intValue();
170 private LogManager manager;
171 private String name;
172 private final CopyOnWriteArrayList<Handler> handlers =
173 new CopyOnWriteArrayList<Handler>();
174 private String resourceBundleName;
175 private volatile boolean useParentHandlers = true;
176 private volatile Filter filter;
177 private boolean anonymous;
178
179 private ResourceBundle catalog; // Cached resource bundle
180 private String catalogName; // name associated with catalog
181 private Locale catalogLocale; // locale associated with catalog
182
183 // The fields relating to parent-child relationships and levels
184 // are managed under a separate lock, the treeLock.
185 private static Object treeLock = new Object();
186 // We keep weak references from parents to children, but strong
187 // references from children to parents.
188 private volatile Logger parent; // our nearest parent.
189 private ArrayList<LogManager.LoggerWeakRef> kids; // WeakReferences to loggers that have us as parent
190 private volatile Level levelObject;
191 private volatile int levelValue; // current effective level value
192
193 /**
1403 LogManager.LoggerWeakRef ref = null;
1404 if (parent != null) {
1405 // assert parent.kids != null;
1406 for (Iterator<LogManager.LoggerWeakRef> iter = parent.kids.iterator(); iter.hasNext(); ) {
1407 ref = iter.next();
1408 Logger kid = ref.get();
1409 if (kid == this) {
1410 // ref is used down below to complete the reparenting
1411 iter.remove();
1412 break;
1413 } else {
1414 ref = null;
1415 }
1416 }
1417 // We have now removed ourself from our parents' kids.
1418 }
1419
1420 // Set our new parent.
1421 parent = newParent;
1422 if (parent.kids == null) {
1423 parent.kids = new ArrayList<LogManager.LoggerWeakRef>(2);
1424 }
1425 if (ref == null) {
1426 // we didn't have a previous parent
1427 ref = manager.new LoggerWeakRef(this);
1428 }
1429 ref.setParentRef(new WeakReference<Logger>(parent));
1430 parent.kids.add(ref);
1431
1432 // As a result of the reparenting, the effective level
1433 // may have changed for us and our children.
1434 updateEffectiveLevel();
1435
1436 }
1437 }
1438
1439 // Package-level method.
1440 // Remove the weak reference for the specified child Logger from the
1441 // kid list. We should only be called from LoggerWeakRef.dispose().
1442 final void removeChildLogger(LogManager.LoggerWeakRef child) {
1443 synchronized (treeLock) {
1444 for (Iterator<LogManager.LoggerWeakRef> iter = kids.iterator(); iter.hasNext(); ) {
1445 LogManager.LoggerWeakRef ref = iter.next();
1446 if (ref == child) {
1447 iter.remove();
1448 return;
1449 }
|
153 * provide its own implementation of named Loggers for any point in
154 * the namespace. Therefore, any subclasses of Logger (unless they
155 * are implemented in conjunction with a new LogManager class) should
156 * take care to obtain a Logger instance from the LogManager class and
157 * should delegate operations such as "isLoggable" and "log(LogRecord)"
158 * to that instance. Note that in order to intercept all logging
159 * output, subclasses need only override the log(LogRecord) method.
160 * All the other logging methods are implemented as calls on this
161 * log(LogRecord) method.
162 *
163 * @since 1.4
164 */
165
166
167 public class Logger {
168 private static final Handler emptyHandlers[] = new Handler[0];
169 private static final int offValue = Level.OFF.intValue();
170 private LogManager manager;
171 private String name;
172 private final CopyOnWriteArrayList<Handler> handlers =
173 new CopyOnWriteArrayList<>();
174 private String resourceBundleName;
175 private volatile boolean useParentHandlers = true;
176 private volatile Filter filter;
177 private boolean anonymous;
178
179 private ResourceBundle catalog; // Cached resource bundle
180 private String catalogName; // name associated with catalog
181 private Locale catalogLocale; // locale associated with catalog
182
183 // The fields relating to parent-child relationships and levels
184 // are managed under a separate lock, the treeLock.
185 private static Object treeLock = new Object();
186 // We keep weak references from parents to children, but strong
187 // references from children to parents.
188 private volatile Logger parent; // our nearest parent.
189 private ArrayList<LogManager.LoggerWeakRef> kids; // WeakReferences to loggers that have us as parent
190 private volatile Level levelObject;
191 private volatile int levelValue; // current effective level value
192
193 /**
1403 LogManager.LoggerWeakRef ref = null;
1404 if (parent != null) {
1405 // assert parent.kids != null;
1406 for (Iterator<LogManager.LoggerWeakRef> iter = parent.kids.iterator(); iter.hasNext(); ) {
1407 ref = iter.next();
1408 Logger kid = ref.get();
1409 if (kid == this) {
1410 // ref is used down below to complete the reparenting
1411 iter.remove();
1412 break;
1413 } else {
1414 ref = null;
1415 }
1416 }
1417 // We have now removed ourself from our parents' kids.
1418 }
1419
1420 // Set our new parent.
1421 parent = newParent;
1422 if (parent.kids == null) {
1423 parent.kids = new ArrayList<>(2);
1424 }
1425 if (ref == null) {
1426 // we didn't have a previous parent
1427 ref = manager.new LoggerWeakRef(this);
1428 }
1429 ref.setParentRef(new WeakReference<>(parent));
1430 parent.kids.add(ref);
1431
1432 // As a result of the reparenting, the effective level
1433 // may have changed for us and our children.
1434 updateEffectiveLevel();
1435
1436 }
1437 }
1438
1439 // Package-level method.
1440 // Remove the weak reference for the specified child Logger from the
1441 // kid list. We should only be called from LoggerWeakRef.dispose().
1442 final void removeChildLogger(LogManager.LoggerWeakRef child) {
1443 synchronized (treeLock) {
1444 for (Iterator<LogManager.LoggerWeakRef> iter = kids.iterator(); iter.hasNext(); ) {
1445 LogManager.LoggerWeakRef ref = iter.next();
1446 if (ref == child) {
1447 iter.remove();
1448 return;
1449 }
|