GrepCode: java.util.logging.Logger (.java) - Class

JDK
/
jdk / openjdk
/
6-b14

7-b147
6-b14
/
java.util.logging.Logger

Find Usages

Diff

Raw

Download

HTML Widget

Stack Overflow Q&A

Stack Overflow Questions

1. Examples of GoF Design Patterns

I am learning GoF Java Design Patterns and I want to see some real life examples of them. Can you guys point to some good usage of these Design Patterns.(preferably in Java's core libraries). Thank you

2. How do I get java logging output to appear on a single line?

At the moment a default entry looks something like this: Oct 12, 2008 9:45:18 AM myClassInfoHere INFO: MyLogMessageHere How do I get it to do this? Oct 12, 2008 9:45:18 AM myClassInfoHere - INFO: MyLogMessageHere Clarification I'm using java.util.logging

3. Compare log4j and Logger

How does The JDK's Logger compare to Apache log4j? Which one is better for new projects that target Java 6? How do they compare in terms of flexibility and configurability?

4. Java - Need a logging package that will log the stacktrace

Is there a Logger that will easily log my stacktrace (what I get with ex.printStackTrace())? I've searched the log4j docs and found nothing about logging the stacktrace. I can do this myself with StringWriter sw = new StringWriter(); ex.printStackTrace(new PrintWriter(sw)); String stacktrace = sw.toString(); logger.error(stacktrace); but I don't want to duplicate this code all over the plac...

5. How to choose between methods of acquiring dependencies?

I've seen at least three ways of acquiring dependencies in a Java object without coupling the object to the creation of the dependency; Dependency Injection - some framework injects a required object into another object based on an external configuration, example: Spring managed beans Dependency Lookup - a class looks up a required dependency in some kind of directory service, example: JNDI l...

6. Disable logging in Java at compile time

I have some Java code that I'd like to instrument with log messages for debugging purposes. The final (compiled) production code, however, should not contain any logging as it would slow down the execution time. Is there any way in Java to disable a logger at compile time? I am not afraid of the footprint a check inside the log method of a run-time enabled/disabled logger would add. if (loggi...

7. Logger vs. System.out.println

I'm using the PMD plugin for eclipse and it gives me an error when using System.out.println() with the explanation: System.(out|err).print is used, consider using a logger. My question is - What is a Logger? How is it used to print to the screen? Why is it better? Thanks.

8. Set loglevel for some Loggers, but not others

I'm developing a Java application that uses java.util.logging for its logging needs. This application uses a multitude of external libraries (JDBC, JMS clients, JSR-160 implementation, etc), some of which also use java.util.logging. I want to set the log level for my Loggers to ALL when I specify a flag on the command line, but so far I have only found ways to set the level for all loggers, no...

9. Why a new instance uses logger from old instances?

I generate 2 instances in this way: gameManager manager1 = new CTManager(owner,players1,"en"); manager1.start(); gameManager manager2 = new CTManager(owner,players2,"en"); manager2.start(); The start() method of the gameManager looks like that: void start() { game.start(); } When I create the game instance I create a loger: log = Logger.getLogger("TestLog"); (log is a ...

10. How to prove a bug in this piece of code via unit test

we have a habit in our company that when a bug is reported we do following steps: Write a unit test that fails clearly showing the bug exists Fix the bug Re-run the test to prove the bug has been fixed Commit the fix and the test to avoid regressions in the future Now I came across a piece of legacy code with very easy bug. Situation looks like follows: public final class SomeClass { ....

11. Logging in Java

I am creating a logger in java by executing the following code: private static final String logFile = "." + File.separator + "Log Files" + File.separator + "Log_" + Long.toString(System.currentTimeMillis()); private static Logger logger = Logger.getLogger("JCS_Logger"); static { try { logger.addHandler(new FileHandler(logFile )); } catch (Exception e) { Sys...

12. Java Logger only to file, no screen output!

I got a quite simple problem but cant find a solution for it. I have a logger with a file handler added, but it still spams to hell out of my console. How could I get the logger to solely route all output to a file, with NO console outputs? Thanks a lot, cru

13. How do I write to the console in Google App Engine (JAVA)?

I am using eclipse and java sdk of app-engine. I found the link for same question here and on stackoverflow here. But both are for python. Is there a way to do it in eclipse?

14. SLF4J debugging level configuration + Logging framework integration

I am considering using SLF4j to integrate multiple logging frameworks. The java.util.logging.Logger class has a nice method called setLevel(Level newLevel). It enables logging configuration at a class level, which helps creating readable and lean traces. I could not find the equivalent in the SLF4J framework. Is there any? The SLF4J Logger interface does not offer such a method. I have seen ...

15. SLF4J, Common Logging, console output

I have this 3rd party library that has: slf4j-api-1.5.5.jar slf4j-jdk14-1.5.5.jar jcl-over-slf4j-1.5.5.jar I want to write some tests against this library and see its log output, and I don't want to add any more logging libraries (no log4j or anything else). I understand that SLF4J and Common Logging are both logging abstractions so I probably need to write my own simple concrete logger (...

16. What is "logger" in Java?

I have a class in which I see the following things: this.logger.severe(""); this.logger.warning(""); this.logger.info(""); I do not understand several things: How can we use a method that was not defined earlier? I mean, there are no "logger" methods defined in the class. I thought that these methods could be defined because the considered class is an extension of another class in which th...

17. Adhering to logging standard while using Google Guice?

The Java docs for Logger indicate that the logger name should be based on the class name. Google Guice handles this in BinderImpl.java where it does the following: return member == null ? Logger.getAnonymousLogger() : Logger.getLogger(member.getDeclaringClass().getName()); However, since it's getting a new logger for each class, I would lose access to whatever Handler's may have...

18. Java.util.logging message template question

NetBeans recommended that I change the way that logging statements that have string concatenation are written, stating Convert string concatenation to a message template so that a statement such as: log.severe("Completed at: " + new Date()); got changed to log.log(Level.SEVERE, "Completed at: {0}", new Date()); The problem is that now the Date doesn't get printed. Instead, the string "{...

19. Loggers in GWT Client Side

Is there a way to report log messages in a Client-side GWT applications for development purposes (in Standard GWT libraries i.e. No external libraries)? i.e. like the Logger that can be used to output log messages to catalina.out when developing things for say Tomcat.

20. Logger related question in java

From java.util.logging.Logger: Logger names can be arbitrary strings, but they should normally be based on the package name or class name of the logged component, such as java.net or javax.swing Could anyone explain this sentence to me ?

21. How to use log levels in java

HI All, I am developing one application their i need to use the logger for that i read all the levels of logger which are * SEVERE (highest) * WARNING * INFO * CONFIG * FINE * FINER * FINEST but i am not understand how to use that level can anyone give me the good example of all the levels and at what condition we can use all the levels and how? Thanks A lot...

1
   /*
2
    * Copyright 2000-2006 Sun Microsystems, Inc.  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.  Sun designates this
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
   * CA 95054 USA or visit www.sun.com if you need additional information or
23
   * have any questions.
24
   */
25
  
26
  
27
  package java.util.logging;
28
  
29
  import java.util.*;
30
  import java.security.*;
31
  import java.lang.ref.WeakReference;

 A Logger object is used to log messages for a specific
 system or application component.  Loggers are normally named,
 using a hierarchical dot-separated namespace.  Logger names
 can be arbitrary strings, but they should normally be based on
 the package name or class name of the logged component, such
 as java.net or javax.swing.  In addition it is possible to create
 "anonymous" Loggers that are not stored in the Logger namespace.
 
 Logger objects may be obtained by calls on one of the getLogger
 factory methods.  These will either create a new Logger or
 return a suitable existing Logger.
 

 Logging messages will be forwarded to registered Handler
 objects, which can forward the messages to a variety of
 destinations, including consoles, files, OS logs, etc.
 

 Each Logger keeps track of a "parent" Logger, which is its
 nearest existing ancestor in the Logger namespace.
 

 Each Logger has a "Level" associated with it.  This reflects
 a minimum Level that this logger cares about.  If a Logger's
 level is set to null, then its effective level is inherited
 from its parent, which may in turn obtain it recursively from its
 parent, and so on up the tree.
 

 The log level can be configured based on the properties from the
 logging configuration file, as described in the description
 of the LogManager class.  However it may also be dynamically changed
 by calls on the Logger.setLevel method.  If a logger's level is
 changed the change may also affect child loggers, since any child
 logger that has null as its level will inherit its
 effective level from its parent.
 

 On each logging call the Logger initially performs a cheap
 check of the request level (e.g. SEVERE or FINE) against the
 effective log level of the logger.  If the request level is
 lower than the log level, the logging call returns immediately.
 

 After passing this initial (cheap) test, the Logger will allocate
 a LogRecord to describe the logging message.  It will then call a
 Filter (if present) to do a more detailed check on whether the
 record should be published.  If that passes it will then publish
 the LogRecord to its output Handlers.  By default, loggers also
 publish to their parent's Handlers, recursively up the tree.
 

 Each Logger may have a ResourceBundle name associated with it.
 The named bundle will be used for localizing logging messages.
 If a Logger does not have its own ResourceBundle name, then
 it will inherit the ResourceBundle name from its parent,
 recursively up the tree.
 

 Most of the logger output methods take a "msg" argument.  This
 msg argument may be either a raw value or a localization key.
 During formatting, if the logger has (or inherits) a localization
 ResourceBundle and if the ResourceBundle has a mapping for the msg
 string, then the msg string is replaced by the localized value.
 Otherwise the original msg string is used.  Typically, formatters use
 java.text.MessageFormat style formatting to format parameters, so
 for example a format string "{0} {1}" would format two parameters
 as strings.
 

 When mapping ResourceBundle names to ResourceBundles, the Logger
 will first try to use the Thread's ContextClassLoader.  If that
 is null it will try the SystemClassLoader instead.  As a temporary
 transition feature in the initial implementation, if the Logger is
 unable to locate a ResourceBundle from the ContextClassLoader or
 SystemClassLoader the Logger will also search up the class stack
 and use successive calling ClassLoaders to try to locate a ResourceBundle.
 (This call stack search is to allow containers to transition to
 using ContextClassLoaders and is likely to be removed in future
 versions.)
 

 Formatting (including localization) is the responsibility of
 the output Handler, which will typically call a Formatter.
 

 Note that formatting need not occur synchronously.  It may be delayed
 until a LogRecord is actually written to an external sink.
 

 The logging methods are grouped in five main categories:
 

     There are a set of "log" methods that take a log level, a message
     string, and optionally some parameters to the message string.
 

     There are a set of "logp" methods (for "log precise") that are
     like the "log" methods, but also take an explicit source class name
     and method name.
 

     There are a set of "logrb" method (for "log with resource bundle")
     that are like the "logp" method, but also take an explicit resource
     bundle name for use in localizing the log message.
 

     There are convenience methods for tracing method entries (the
     "entering" methods), method returns (the "exiting" methods) and
     throwing exceptions (the "throwing" methods).
 

     Finally, there are a set of convenience methods for use in the
     very simplest cases, when a developer simply wants to log a
     simple string at a given log level.  These methods are named
     after the standard Level names ("severe", "warning", "info", etc.)
     and take a single argument, a message string.
 

 For the methods that do not take an explicit source name and
 method name, the Logging framework will make a "best effort"
 to determine which class and method called into the logging method.
 However, it is important to realize that this automatically inferred
 information may only be approximate (or may even be quite wrong!).
 Virtual machines are allowed to do extensive optimizations when
 JITing and may entirely remove stack frames, making it impossible
 to reliably locate the calling class and method.
 

 All methods on Logger are multi-thread safe.
 

 Subclassing Information: Note that a LogManager class may
 provide its own implementation of named Loggers for any point in
 the namespace.  Therefore, any subclasses of Logger (unless they
 are implemented in conjunction with a new LogManager class) should
 take care to obtain a Logger instance from the LogManager class and
 should delegate operations such as "isLoggable" and "log(LogRecord)"
 to that instance.  Note that in order to intercept all logging
 output, subclasses need only override the log(LogRecord) method.
 All the other logging methods are implemented as calls on this
 log(LogRecord) method.

 
 Since:1.4
160
 
161
 
162
 
163
 public class Logger {
164
     private static final Handler emptyHandlers[] = new Handler[0];
165
     private static final int offValue = Level.OFF.intValue();
166
     private LogManager manager;
167
     private String name;
168
     private ArrayList<Handler> handlers;
169
     private String resourceBundleName;
170
     private boolean useParentHandlers = true;
171
     private Filter filter;
172
     private boolean anonymous;
173
 
174
     private ResourceBundle catalog;     // Cached resource bundle
175
     private String catalogName;         // name associated with catalog
176
     private Locale catalogLocale;       // locale associated with catalog
177
 
178
     // The fields relating to parent-child relationships and levels
179
     // are managed under a separate lock, the treeLock.
180
     private static Object treeLock = new Object();
181
     // We keep weak references from parents to children, but strong
182
     // references from children to parents.
183
     private Logger parent;    // our nearest parent.
184
     private ArrayList<WeakReference<Logger>> kids;   // WeakReferences to loggers that have us as parent
185
     private Level levelObject;
186
     private volatile int levelValue;  // current effective level value
187
 
    
 GLOBAL_LOGGER_NAME is a name for the global logger.
 This name is provided as a convenience to developers who are making
 casual use of the Logging package.  Developers who are making serious
 use of the logging package (for example in products) should create
 and use their own Logger objects, with appropriate names, so that
 logging can be controlled on a suitable per-Logger granularity.
 
 The preferred way to get the global logger object is via the call
 Logger.getLogger(Logger.GLOBAL_LOGGER_NAME).
 
 Since:1.6
199
 
200
     public static final String GLOBAL_LOGGER_NAME = "global";

    
 The "global" Logger object is provided as a convenience to developers
 who are making casual use of the Logging package.  Developers
 who are making serious use of the logging package (for example
 in products) should create and use their own Logger objects,
 with appropriate names, so that logging can be controlled on a
 suitable per-Logger granularity.
 
 
 Deprecated:Initialization of this field is prone to deadlocks.
 The field must be initialized by the Logger class initialization
 which may cause deadlocks with the LogManager class initialization.
 In such cases two class initialization wait for each other to complete.
 As of JDK version 1.6, the preferred way to get the global logger object
 is via the call Logger.getLogger(Logger.GLOBAL_LOGGER_NAME).
216
 
217
     @Deprecated
218
     public static final Logger global = new Logger(GLOBAL_LOGGER_NAME);

    
 Protected method to construct a logger for a named subsystem.
 
 The logger will be initially configured with a null Level
 and with useParentHandlers true.

 
 Parameters:name    A name for the logger.  This should
                          be a dot-separated name and should normally
                          be based on the package name or class name
                          of the subsystem, such as java.net
                          or javax.swing.  It may be null for anonymous Loggers.resourceBundleName  name of ResourceBundle to be used for localizing
                          messages for this logger.  May be null if none
                          of the messages require localization. Throws:java.util.MissingResourceException if the ResourceBundleName is non-null and
             no corresponding resource can be found.
236
 
237
     protected Logger(String name, String resourceBundleName) {
238
         this.manager = LogManager.getLogManager();
239
         if (resourceBundleName != null) {
240
             // Note: we may get a MissingResourceException here.
241
             setupResourceInfo(resourceBundleName);
242
         }
243
         this.name = name;
244
         levelValue = Level.INFO.intValue();
245
     }
246
 
247
     // This constructor is used only to create the global Logger.
248
     // It is needed to break a cyclic dependence between the LogManager
249
     // and Logger static initializers causing deadlocks.
250
     private Logger(String name) {
251
         // The manager field is not initialized here.
252
         this.name = name;
253
         levelValue = Level.INFO.intValue();
254
     }
255
 
256
     // It is called from the LogManager.<clinit> to complete
257
     // initialization of the global Logger.
258
     void setLogManager(LogManager manager) {
259
         this.manager = manager;
260
     }
261
 
262
     private void checkAccess() throws SecurityException {
263
         if (!anonymous) {
264
             if (manager == null) {
265
                 // Complete initialization of the global Logger.
266
                 manager = LogManager.getLogManager();
267
             }
268
             manager.checkAccess();
269
         }
270
     }

    
 Find or create a logger for a named subsystem.  If a logger has
 already been created with the given name it is returned.  Otherwise
 a new logger is created.
 
 If a new logger is created its log level will be configured
 based on the LogManager configuration and it will configured
 to also send logging output to its parent's handlers.  It will
 be registered in the LogManager global namespace.

 
 Parameters:name            A name for the logger.  This should
                          be a dot-separated name and should normally
                          be based on the package name or class name
                          of the subsystem, such as java.net
                          or javax.swing Returns:a suitable Logger Throws:java.lang.NullPointerException if the name is null.
289
 
290
     public static synchronized Logger getLogger(String name) {
291
         LogManager manager = LogManager.getLogManager();
292
         return manager.demandLogger(name);
293
     }

    
 Find or create a logger for a named subsystem.  If a logger has
 already been created with the given name it is returned.  Otherwise
 a new logger is created.
 
 If a new logger is created its log level will be configured
 based on the LogManager and it will configured to also send logging
 output to its parent loggers Handlers.  It will be registered in
 the LogManager global namespace.
 

 If the named Logger already exists and does not yet have a
 localization resource bundle then the given resource bundle
 name is used.  If the named Logger already exists and has
 a different resource bundle name then an IllegalArgumentException
 is thrown.
 

 
 Parameters:name    A name for the logger.  This should
                          be a dot-separated name and should normally
                          be based on the package name or class name
                          of the subsystem, such as java.net
                          or javax.swingresourceBundleName  name of ResourceBundle to be used for localizing
                          messages for this logger. May be null if none of
                          the messages require localization. Returns:a suitable Logger Throws:java.util.MissingResourceException if the named ResourceBundle cannot be found.java.lang.IllegalArgumentException if the Logger already exists and uses
             a different resource bundle name.java.lang.NullPointerException if the name is null.
324
 
325
     public static synchronized Logger getLogger(String name, String resourceBundleName) {
326
         LogManager manager = LogManager.getLogManager();
327
         Logger result = manager.demandLogger(name);
328
         if (result.resourceBundleName == null) {
329
             // Note: we may get a MissingResourceException here.
330
             result.setupResourceInfo(resourceBundleName);
331
         } else if (!result.resourceBundleName.equals(resourceBundleName)) {
332
             throw new IllegalArgumentException(result.resourceBundleName +
333
                                 " != " + resourceBundleName);
334
         }
335
         return result;
336
     }


    
 Create an anonymous Logger.  The newly created Logger is not
 registered in the LogManager namespace.  There will be no
 access checks on updates to the logger.
 
 This factory method is primarily intended for use from applets.
 Because the resulting Logger is anonymous it can be kept private
 by the creating class.  This removes the need for normal security
 checks, which in turn allows untrusted applet code to update
 the control state of the Logger.  For example an applet can do
 a setLevel or an addHandler on an anonymous Logger.
 

 Even although the new logger is anonymous, it is configured
 to have the root logger ("") as its parent.  This means that
 by default it inherits its effective level and handlers
 from the root logger.
 


 
 Returns:a newly created private Logger
358
 
359
     public static synchronized Logger getAnonymousLogger() {
360
         LogManager manager = LogManager.getLogManager();
361
         Logger result = new Logger(null, null);
362
         result.anonymous = true;
363
         Logger root = manager.getLogger("");
364
         result.doSetParent(root);
365
         return result;
366
     }

    
 Create an anonymous Logger.  The newly created Logger is not
 registered in the LogManager namespace.  There will be no
 access checks on updates to the logger.
 
 This factory method is primarily intended for use from applets.
 Because the resulting Logger is anonymous it can be kept private
 by the creating class.  This removes the need for normal security
 checks, which in turn allows untrusted applet code to update
 the control state of the Logger.  For example an applet can do
 a setLevel or an addHandler on an anonymous Logger.
 

 Even although the new logger is anonymous, it is configured
 to have the root logger ("") as its parent.  This means that
 by default it inherits its effective level and handlers
 from the root logger.
 

 
 Parameters:resourceBundleName  name of ResourceBundle to be used for localizing
                          messages for this logger.
          May be null if none of the messages require localization. Returns:a newly created private Logger Throws:java.util.MissingResourceException if the named ResourceBundle cannot be found.
390
 
391
     public static synchronized Logger getAnonymousLogger(String resourceBundleName) {
392
         LogManager manager = LogManager.getLogManager();
393
         Logger result = new Logger(null, resourceBundleName);
394
         result.anonymous = true;
395
         Logger root = manager.getLogger("");
396
         result.doSetParent(root);
397
         return result;
398
     }

    
 Retrieve the localization resource bundle for this
 logger for the current default locale.  Note that if
 the result is null, then the Logger will use a resource
 bundle inherited from its parent.

 
 Returns:localization bundle (may be null)
407
 
408
     public ResourceBundle getResourceBundle() {
409
         return findResourceBundle(getResourceBundleName());
410
     }

    
 Retrieve the localization resource bundle name for this
 logger.  Note that if the result is null, then the Logger
 will use a resource bundle name inherited from its parent.

 
 Returns:localization bundle name (may be null)
418
 
419
     public String getResourceBundleName() {
420
         return resourceBundleName;
421
     }

    
 Set a filter to control output on this Logger.
 
 After passing the initial "level" check, the Logger will
 call this Filter to check if a log record should really
 be published.

 
 Parameters:newFilter  a filter object (may be null) Throws:java.lang.SecurityException  if a security manager exists and if
             the caller does not have LoggingPermission("control").
433
 
434
     public synchronized void setFilter(Filter newFilter) throws SecurityException {
435
         checkAccess();
436
         filter = newFilter;
437
     }

    
 Get the current filter for this Logger.

 
 Returns:a filter object (may be null)
443
 
444
     public synchronized Filter getFilter() {
445
         return filter;
446
     }

    
 Log a LogRecord.
 
 All the other logging methods in this class call through
 this method to actually perform any logging.  Subclasses can
 override this single method to capture all log activity.

 
 Parameters:record the LogRecord to be published
456
 
457
     public void log(LogRecord record) {
458
         if (record.getLevel().intValue() < levelValue || levelValue == offValue) {
459
             return;
460
         }
461
         synchronized (this) {
462
             if (filter != null && !filter.isLoggable(record)) {
463
                 return;
464
             }
465
         }
466
 
467
         // Post the LogRecord to all our Handlers, and then to
468
         // our parents' handlers, all the way up the tree.
469
 
470
         Logger logger = this;
471
         while (logger != null) {
472
             Handler targets[] = logger.getHandlers();
473
 
474
             if (targets != null) {
475
                 for (int i = 0; i < targets.length; i++) {
476
                     targets[i].publish(record);
477
                 }
478
             }
479
 
480
             if (!logger.getUseParentHandlers()) {
481
                 break;
482
             }
483
 
484
             logger = logger.getParent();
485
         }
486
     }
487
 
488
     // private support method for logging.
489
     // We fill in the logger name, resource bundle name, and
490
     // resource bundle and then call "void log(LogRecord)".
491
     private void doLog(LogRecord lr) {
492
         lr.setLoggerName(name);
493
         String ebname = getEffectiveResourceBundleName();
494
         if (ebname != null) {
495
             lr.setResourceBundleName(ebname);
496
             lr.setResourceBundle(findResourceBundle(ebname));
497
         }
498
         log(lr);
499
     }
500
 
501
 
502
     //================================================================
503
     // Start of convenience methods WITHOUT className and methodName
504
     //================================================================
505
 
    
 Log a message, with no arguments.
 
 If the logger is currently enabled for the given message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREmsg     The string message (or a key in the message catalog)
515
 
516
     public void log(Level level, String msg) {
517
         if (level.intValue() < levelValue || levelValue == offValue) {
518
             return;
519
         }
520
         LogRecord lr = new LogRecord(level, msg);
521
         doLog(lr);
522
     }

    
 Log a message, with one object parameter.
 
 If the logger is currently enabled for the given message
 level then a corresponding LogRecord is created and forwarded
 to all the registered output Handler objects.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREmsg     The string message (or a key in the message catalog)param1  parameter to the message
534
 
535
     public void log(Level level, String msg, Object param1) {
536
         if (level.intValue() < levelValue || levelValue == offValue) {
537
             return;
538
         }
539
         LogRecord lr = new LogRecord(level, msg);
540
         Object params[] = { param1 };
541
         lr.setParameters(params);
542
         doLog(lr);
543
     }

    
 Log a message, with an array of object arguments.
 
 If the logger is currently enabled for the given message
 level then a corresponding LogRecord is created and forwarded
 to all the registered output Handler objects.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREmsg     The string message (or a key in the message catalog)params  array of parameters to the message
555
 
556
     public void log(Level level, String msg, Object params[]) {
557
         if (level.intValue() < levelValue || levelValue == offValue) {
558
             return;
559
         }
560
         LogRecord lr = new LogRecord(level, msg);
561
         lr.setParameters(params);
562
         doLog(lr);
563
     }

    
 Log a message, with associated Throwable information.
 
 If the logger is currently enabled for the given message
 level then the given arguments are stored in a LogRecord
 which is forwarded to all registered output handlers.
 

 Note that the thrown argument is stored in the LogRecord thrown
 property, rather than the LogRecord parameters property.  Thus is it
 processed specially by output Formatters and is not treated
 as a formatting parameter to the LogRecord message property.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREmsg     The string message (or a key in the message catalog)thrown  Throwable associated with log message.
580
 
581
     public void log(Level level, String msg, Throwable thrown) {
582
         if (level.intValue() < levelValue || levelValue == offValue) {
583
             return;
584
         }
585
         LogRecord lr = new LogRecord(level, msg);
586
         lr.setThrown(thrown);
587
         doLog(lr);
588
     }
589
 
590
     //================================================================
591
     // Start of convenience methods WITH className and methodName
592
     //================================================================
593
 
    
 Log a message, specifying source class and method,
 with no arguments.
 
 If the logger is currently enabled for the given message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREsourceClass    name of class that issued the logging requestsourceMethod   name of method that issued the logging requestmsg     The string message (or a key in the message catalog)
606
 
607
     public void logp(Level level, String sourceClass, String sourceMethod, String msg) {
608
         if (level.intValue() < levelValue || levelValue == offValue) {
609
             return;
610
         }
611
         LogRecord lr = new LogRecord(level, msg);
612
         lr.setSourceClassName(sourceClass);
613
         lr.setSourceMethodName(sourceMethod);
614
         doLog(lr);
615
     }

    
 Log a message, specifying source class and method,
 with a single object parameter to the log message.
 
 If the logger is currently enabled for the given message
 level then a corresponding LogRecord is created and forwarded
 to all the registered output Handler objects.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREsourceClass    name of class that issued the logging requestsourceMethod   name of method that issued the logging requestmsg      The string message (or a key in the message catalog)param1    Parameter to the log message.
630
 
631
     public void logp(Level level, String sourceClass, String sourceMethod,
632
                                                 String msg, Object param1) {
633
         if (level.intValue() < levelValue || levelValue == offValue) {
634
             return;
635
         }
636
         LogRecord lr = new LogRecord(level, msg);
637
         lr.setSourceClassName(sourceClass);
638
         lr.setSourceMethodName(sourceMethod);
639
         Object params[] = { param1 };
640
         lr.setParameters(params);
641
         doLog(lr);
642
     }

    
 Log a message, specifying source class and method,
 with an array of object arguments.
 
 If the logger is currently enabled for the given message
 level then a corresponding LogRecord is created and forwarded
 to all the registered output Handler objects.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREsourceClass    name of class that issued the logging requestsourceMethod   name of method that issued the logging requestmsg     The string message (or a key in the message catalog)params  Array of parameters to the message
657
 
658
     public void logp(Level level, String sourceClass, String sourceMethod,
659
                                                 String msg, Object params[]) {
660
         if (level.intValue() < levelValue || levelValue == offValue) {
661
             return;
662
         }
663
         LogRecord lr = new LogRecord(level, msg);
664
         lr.setSourceClassName(sourceClass);
665
         lr.setSourceMethodName(sourceMethod);
666
         lr.setParameters(params);
667
         doLog(lr);
668
     }

    
 Log a message, specifying source class and method,
 with associated Throwable information.
 
 If the logger is currently enabled for the given message
 level then the given arguments are stored in a LogRecord
 which is forwarded to all registered output handlers.
 

 Note that the thrown argument is stored in the LogRecord thrown
 property, rather than the LogRecord parameters property.  Thus is it
 processed specially by output Formatters and is not treated
 as a formatting parameter to the LogRecord message property.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREsourceClass    name of class that issued the logging requestsourceMethod   name of method that issued the logging requestmsg     The string message (or a key in the message catalog)thrown  Throwable associated with log message.
688
 
689
     public void logp(Level level, String sourceClass, String sourceMethod,
690
                                                         String msg, Throwable thrown) {
691
         if (level.intValue() < levelValue || levelValue == offValue) {
692
             return;
693
         }
694
         LogRecord lr = new LogRecord(level, msg);
695
         lr.setSourceClassName(sourceClass);
696
         lr.setSourceMethodName(sourceMethod);
697
         lr.setThrown(thrown);
698
         doLog(lr);
699
     }
700
 
701
 
702
     //=========================================================================
703
     // Start of convenience methods WITH className, methodName and bundle name.
704
     //=========================================================================
705
 
706
     // Private support method for logging for "logrb" methods.
707
     // We fill in the logger name, resource bundle name, and
708
     // resource bundle and then call "void log(LogRecord)".
709
     private void doLog(LogRecord lr, String rbname) {
710
         lr.setLoggerName(name);
711
         if (rbname != null) {
712
             lr.setResourceBundleName(rbname);
713
             lr.setResourceBundle(findResourceBundle(rbname));
714
         }
715
         log(lr);
716
     }

    
 Log a message, specifying source class, method, and resource bundle name
 with no arguments.
 
 If the logger is currently enabled for the given message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 The msg string is localized using the named resource bundle.  If the
 resource bundle name is null, or an empty String or invalid
 then the msg string is not localized.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREsourceClass    name of class that issued the logging requestsourceMethod   name of method that issued the logging requestbundleName     name of resource bundle to localize msg,
                         can be nullmsg     The string message (or a key in the message catalog)
736
 
737
 
738
     public void logrb(Level level, String sourceClass, String sourceMethod,
739
                                 String bundleName, String msg) {
740
         if (level.intValue() < levelValue || levelValue == offValue) {
741
             return;
742
         }
743
         LogRecord lr = new LogRecord(level, msg);
744
         lr.setSourceClassName(sourceClass);
745
         lr.setSourceMethodName(sourceMethod);
746
         doLog(lr, bundleName);
747
     }

    
 Log a message, specifying source class, method, and resource bundle name,
 with a single object parameter to the log message.
 
 If the logger is currently enabled for the given message
 level then a corresponding LogRecord is created and forwarded
 to all the registered output Handler objects.
 

 The msg string is localized using the named resource bundle.  If the
 resource bundle name is null, or an empty String or invalid
 then the msg string is not localized.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREsourceClass    name of class that issued the logging requestsourceMethod   name of method that issued the logging requestbundleName     name of resource bundle to localize msg,
                         can be nullmsg      The string message (or a key in the message catalog)param1    Parameter to the log message.
768
 
769
     public void logrb(Level level, String sourceClass, String sourceMethod,
770
                                 String bundleName, String msg, Object param1) {
771
         if (level.intValue() < levelValue || levelValue == offValue) {
772
             return;
773
         }
774
         LogRecord lr = new LogRecord(level, msg);
775
         lr.setSourceClassName(sourceClass);
776
         lr.setSourceMethodName(sourceMethod);
777
         Object params[] = { param1 };
778
         lr.setParameters(params);
779
         doLog(lr, bundleName);
780
     }

    
 Log a message, specifying source class, method, and resource bundle name,
 with an array of object arguments.
 
 If the logger is currently enabled for the given message
 level then a corresponding LogRecord is created and forwarded
 to all the registered output Handler objects.
 

 The msg string is localized using the named resource bundle.  If the
 resource bundle name is null, or an empty String or invalid
 then the msg string is not localized.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREsourceClass    name of class that issued the logging requestsourceMethod   name of method that issued the logging requestbundleName     name of resource bundle to localize msg,
                         can be null.msg     The string message (or a key in the message catalog)params  Array of parameters to the message
801
 
802
     public void logrb(Level level, String sourceClass, String sourceMethod,
803
                                 String bundleName, String msg, Object params[]) {
804
         if (level.intValue() < levelValue || levelValue == offValue) {
805
             return;
806
         }
807
         LogRecord lr = new LogRecord(level, msg);
808
         lr.setSourceClassName(sourceClass);
809
         lr.setSourceMethodName(sourceMethod);
810
         lr.setParameters(params);
811
         doLog(lr, bundleName);
812
     }

    
 Log a message, specifying source class, method, and resource bundle name,
 with associated Throwable information.
 
 If the logger is currently enabled for the given message
 level then the given arguments are stored in a LogRecord
 which is forwarded to all registered output handlers.
 

 The msg string is localized using the named resource bundle.  If the
 resource bundle name is null, or an empty String or invalid
 then the msg string is not localized.
 

 Note that the thrown argument is stored in the LogRecord thrown
 property, rather than the LogRecord parameters property.  Thus is it
 processed specially by output Formatters and is not treated
 as a formatting parameter to the LogRecord message property.
 

 
 Parameters:level   One of the message level identifiers, e.g. SEVEREsourceClass    name of class that issued the logging requestsourceMethod   name of method that issued the logging requestbundleName     name of resource bundle to localize msg,
                         can be nullmsg     The string message (or a key in the message catalog)thrown  Throwable associated with log message.
838
 
839
     public void logrb(Level level, String sourceClass, String sourceMethod,
840
                                         String bundleName, String msg, Throwable thrown) {
841
         if (level.intValue() < levelValue || levelValue == offValue) {
842
             return;
843
         }
844
         LogRecord lr = new LogRecord(level, msg);
845
         lr.setSourceClassName(sourceClass);
846
         lr.setSourceMethodName(sourceMethod);
847
         lr.setThrown(thrown);
848
         doLog(lr, bundleName);
849
     }
850
 
851
 
852
     //======================================================================
853
     // Start of convenience methods for logging method entries and returns.
854
     //======================================================================
855
 
    
 Log a method entry.
 
 This is a convenience method that can be used to log entry
 to a method.  A LogRecord with message "ENTRY", log level
 FINER, and the given sourceMethod and sourceClass is logged.
 

 
 Parameters:sourceClass    name of class that issued the logging requestsourceMethod   name of method that is being entered
865
 
866
     public void entering(String sourceClass, String sourceMethod) {
867
         if (Level.FINER.intValue() < levelValue) {
868
             return;
869
         }
870
         logp(Level.FINER, sourceClass, sourceMethod, "ENTRY");
871
     }

    
 Log a method entry, with one parameter.
 
 This is a convenience method that can be used to log entry
 to a method.  A LogRecord with message "ENTRY {0}", log level
 FINER, and the given sourceMethod, sourceClass, and parameter
 is logged.
 

 
 Parameters:sourceClass    name of class that issued the logging requestsourceMethod   name of method that is being enteredparam1         parameter to the method being entered
884
 
885
     public void entering(String sourceClass, String sourceMethod, Object param1) {
886
         if (Level.FINER.intValue() < levelValue) {
887
             return;
888
         }
889
         Object params[] = { param1 };
890
         logp(Level.FINER, sourceClass, sourceMethod, "ENTRY {0}", params);
891
     }

    
 Log a method entry, with an array of parameters.
 
 This is a convenience method that can be used to log entry
 to a method.  A LogRecord with message "ENTRY" (followed by a
 format {N} indicator for each entry in the parameter array),
 log level FINER, and the given sourceMethod, sourceClass, and
 parameters is logged.
 

 
 Parameters:sourceClass    name of class that issued the logging requestsourceMethod   name of method that is being enteredparams         array of parameters to the method being entered
905
 
906
     public void entering(String sourceClass, String sourceMethod, Object params[]) {
907
         if (Level.FINER.intValue() < levelValue) {
908
             return;
909
         }
910
         String msg = "ENTRY";
911
         if (params == null ) {
912
            logp(Level.FINER, sourceClass, sourceMethod, msg);
913
            return;
914
         }
915
         for (int i = 0; i < params.length; i++) {
916
             msg = msg + " {" + i + "}";
917
         }
918
         logp(Level.FINER, sourceClass, sourceMethod, msg, params);
919
     }

    
 Log a method return.
 
 This is a convenience method that can be used to log returning
 from a method.  A LogRecord with message "RETURN", log level
 FINER, and the given sourceMethod and sourceClass is logged.
 

 
 Parameters:sourceClass    name of class that issued the logging requestsourceMethod   name of the method
930
 
931
     public void exiting(String sourceClass, String sourceMethod) {
932
         if (Level.FINER.intValue() < levelValue) {
933
             return;
934
         }
935
         logp(Level.FINER, sourceClass, sourceMethod, "RETURN");
936
     }


    
 Log a method return, with result object.
 
 This is a convenience method that can be used to log returning
 from a method.  A LogRecord with message "RETURN {0}", log level
 FINER, and the gives sourceMethod, sourceClass, and result
 object is logged.
 

 
 Parameters:sourceClass    name of class that issued the logging requestsourceMethod   name of the methodresult  Object that is being returned
950
 
951
     public void exiting(String sourceClass, String sourceMethod, Object result) {
952
         if (Level.FINER.intValue() < levelValue) {
953
             return;
954
         }
955
         Object params[] = { result };
956
         logp(Level.FINER, sourceClass, sourceMethod, "RETURN {0}", result);
957
     }

    
 Log throwing an exception.
 
 This is a convenience method to log that a method is
 terminating by throwing an exception.  The logging is done
 using the FINER level.
 

 If the logger is currently enabled for the given message
 level then the given arguments are stored in a LogRecord
 which is forwarded to all registered output handlers.  The
 LogRecord's message is set to "THROW".
 

 Note that the thrown argument is stored in the LogRecord thrown
 property, rather than the LogRecord parameters property.  Thus is it
 processed specially by output Formatters and is not treated
 as a formatting parameter to the LogRecord message property.
 

 
 Parameters:sourceClass    name of class that issued the logging requestsourceMethod  name of the method.thrown  The Throwable that is being thrown.
979
 
980
     public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
981
         if (Level.FINER.intValue() < levelValue || levelValue == offValue ) {
982
             return;
983
         }
984
         LogRecord lr = new LogRecord(Level.FINER, "THROW");
985
         lr.setSourceClassName(sourceClass);
986
         lr.setSourceMethodName(sourceMethod);
987
         lr.setThrown(thrown);
988
         doLog(lr);
989
     }
990
 
991
     //=======================================================================
992
     // Start of simple convenience methods using level names as method names
993
     //=======================================================================
994
 
    
 Log a SEVERE message.
 
 If the logger is currently enabled for the SEVERE message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:msg     The string message (or a key in the message catalog)
1003
1004
    public void severe(String msg) {
1005
        if (Level.SEVERE.intValue() < levelValue) {
1006
            return;
1007
        }
1008
        log(Level.SEVERE, msg);
1009
    }

    
 Log a WARNING message.
 
 If the logger is currently enabled for the WARNING message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:msg     The string message (or a key in the message catalog)
1019
1020
    public void warning(String msg) {
1021
        if (Level.WARNING.intValue() < levelValue) {
1022
            return;
1023
        }
1024
        log(Level.WARNING, msg);
1025
    }

    
 Log an INFO message.
 
 If the logger is currently enabled for the INFO message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:msg     The string message (or a key in the message catalog)
1035
1036
    public void info(String msg) {
1037
        if (Level.INFO.intValue() < levelValue) {
1038
            return;
1039
        }
1040
        log(Level.INFO, msg);
1041
    }

    
 Log a CONFIG message.
 
 If the logger is currently enabled for the CONFIG message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:msg     The string message (or a key in the message catalog)
1051
1052
    public void config(String msg) {
1053
        if (Level.CONFIG.intValue() < levelValue) {
1054
            return;
1055
        }
1056
        log(Level.CONFIG, msg);
1057
    }

    
 Log a FINE message.
 
 If the logger is currently enabled for the FINE message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:msg     The string message (or a key in the message catalog)
1067
1068
    public void fine(String msg) {
1069
        if (Level.FINE.intValue() < levelValue) {
1070
            return;
1071
        }
1072
        log(Level.FINE, msg);
1073
    }

    
 Log a FINER message.
 
 If the logger is currently enabled for the FINER message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:msg     The string message (or a key in the message catalog)
1083
1084
    public void finer(String msg) {
1085
        if (Level.FINER.intValue() < levelValue) {
1086
            return;
1087
        }
1088
        log(Level.FINER, msg);
1089
    }

    
 Log a FINEST message.
 
 If the logger is currently enabled for the FINEST message
 level then the given message is forwarded to all the
 registered output Handler objects.
 

 
 Parameters:msg     The string message (or a key in the message catalog)
1099
1100
    public void finest(String msg) {
1101
        if (Level.FINEST.intValue() < levelValue) {
1102
            return;
1103
        }
1104
        log(Level.FINEST, msg);
1105
    }
1106
1107
    //================================================================
1108
    // End of convenience methods
1109
    //================================================================
1110

    
 Set the log level specifying which message levels will be
 logged by this logger.  Message levels lower than this
 value will be discarded.  The level value Level.OFF
 can be used to turn off logging.
 
 If the new level is null, it means that this node should
 inherit its level from its nearest ancestor with a specific
 (non-null) level value.

 
 Parameters:newLevel   the new value for the log level (may be null) Throws:java.lang.SecurityException  if a security manager exists and if
             the caller does not have LoggingPermission("control").
1124
1125
    public void setLevel(Level newLevel) throws SecurityException {
1126
        checkAccess();
1127
        synchronized (treeLock) {
1128
            levelObject = newLevel;
1129
            updateEffectiveLevel();
1130
        }
1131
    }

    
 Get the log Level that has been specified for this Logger.
 The result may be null, which means that this logger's
 effective level will be inherited from its parent.

 
 Returns:this Logger's level
1139
1140
    public Level getLevel() {
1141
        return levelObject;
1142
    }

    
 Check if a message of the given level would actually be logged
 by this logger.  This check is based on the Loggers effective level,
 which may be inherited from its parent.

 
 Parameters:level   a message logging level Returns:true if the given message level is currently being logged.
1151
1152
    public boolean isLoggable(Level level) {
1153
        if (level.intValue() < levelValue || levelValue == offValue) {
1154
            return false;
1155
        }
1156
        return true;
1157
    }

    
 Get the name for this logger.
 
 Returns:logger name.  Will be null for anonymous Loggers.
1162
1163
    public String getName() {
1164
        return name;
1165
    }

    
 Add a log Handler to receive logging messages.
 
 By default, Loggers also send their output to their parent logger.
 Typically the root Logger is configured with a set of Handlers
 that essentially act as default handlers for all loggers.

 
 Parameters:handler a logging Handler Throws:java.lang.SecurityException  if a security manager exists and if
             the caller does not have LoggingPermission("control").
1177
1178
    public synchronized void addHandler(Handler handler) throws SecurityException {
1179
        // Check for null handler
1180
        handler.getClass();
1181
        checkAccess();
1182
        if (handlers == null) {
1183
            handlers = new ArrayList<Handler>();
1184
        }
1185
        handlers.add(handler);
1186
    }

    
 Remove a log Handler.
 
 Returns silently if the given Handler is not found or is null

 
 Parameters:handler a logging Handler Throws:java.lang.SecurityException  if a security manager exists and if
             the caller does not have LoggingPermission("control").
1196
1197
    public synchronized void removeHandler(Handler handler) throws SecurityException {
1198
        checkAccess();
1199
        if (handler == null) {
1200
            return;
1201
        }
1202
        if (handlers == null) {
1203
            return;
1204
        }
1205
        handlers.remove(handler);
1206
    }

    
 Get the Handlers associated with this logger.
 
 
 Returns:an array of all registered Handlers
1212
1213
    public synchronized Handler[] getHandlers() {
1214
        if (handlers == null) {
1215
            return emptyHandlers;
1216
        }
1217
        return handlers.toArray(new Handler[handlers.size()]);
1218
    }

    
 Specify whether or not this logger should send its output
 to it's parent Logger.  This means that any LogRecords will
 also be written to the parent's Handlers, and potentially
 to its parent, recursively up the namespace.

 
 Parameters:useParentHandlers   true if output is to be sent to the
          logger's parent. Throws:java.lang.SecurityException  if a security manager exists and if
             the caller does not have LoggingPermission("control").
1230
1231
    public synchronized void setUseParentHandlers(boolean useParentHandlers) {
1232
        checkAccess();
1233
        this.useParentHandlers = useParentHandlers;
1234
    }

    
 Discover whether or not this logger is sending its output
 to its parent logger.

 
 Returns:true if output is to be sent to the logger's parent
1241
1242
    public synchronized boolean getUseParentHandlers() {
1243
        return useParentHandlers;
1244
    }
1245
1246
    // Private utility method to map a resource bundle name to an
1247
    // actual resource bundle, using a simple one-entry cache.
1248
    // Returns null for a null name.
1249
    // May also return null if we can't find the resource bundle and
1250
    // there is no suitable previous cached value.
1251
1252
    private synchronized ResourceBundle findResourceBundle(String name) {
1253
        // Return a null bundle for a null name.
1254
        if (name == null) {
1255
            return null;
1256
        }
1257
1258
        Locale currentLocale = Locale.getDefault();
1259
1260
        // Normally we should hit on our simple one entry cache.
1261
        if (catalog != null && currentLocale == catalogLocale
1262
                                        && name == catalogName) {
1263
            return catalog;
1264
        }
1265
1266
        // Use the thread's context ClassLoader.  If there isn't one,
1267
        // use the SystemClassloader.
1268
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
1269
        if (cl == null) {
1270
            cl = ClassLoader.getSystemClassLoader();
1271
        }
1272
        try {
1273
            catalog = ResourceBundle.getBundle(name, currentLocale, cl);
1274
            catalogName = name;
1275
            catalogLocale = currentLocale;
1276
            return catalog;
1277
        } catch (MissingResourceException ex) {
1278
            // Woops.  We can't find the ResourceBundle in the default
1279
            // ClassLoader.  Drop through.
1280
        }
1281
1282
1283
        // Fall back to searching up the call stack and trying each
1284
        // calling ClassLoader.
1285
        for (int ix = 0; ; ix++) {
1286
            Class clz = sun.reflect.Reflection.getCallerClass(ix);
1287
            if (clz == null) {
1288
                break;
1289
            }
1290
            ClassLoader cl2 = clz.getClassLoader();
1291
            if (cl2 == null) {
1292
                cl2 = ClassLoader.getSystemClassLoader();
1293
            }
1294
            if (cl == cl2) {
1295
                // We've already checked this classloader.
1296
                continue;
1297
            }
1298
            cl = cl2;
1299
            try {
1300
                catalog = ResourceBundle.getBundle(name, currentLocale, cl);
1301
                catalogName = name;
1302
                catalogLocale = currentLocale;
1303
                return catalog;
1304
            } catch (MissingResourceException ex) {
1305
                // Ok, this one didn't work either.
1306
                // Drop through, and try the next one.
1307
            }
1308
        }
1309
1310
        if (name.equals(catalogName)) {
1311
            // Return the previous cached value for that name.
1312
            // This may be null.
1313
            return catalog;
1314
        }
1315
        // Sorry, we're out of luck.
1316
        return null;
1317
    }
1318
1319
    // Private utility method to initialize our one entry
1320
    // resource bundle cache.
1321
    // Note: for consistency reasons, we are careful to check
1322
    // that a suitable ResourceBundle exists before setting the
1323
    // ResourceBundleName.
1324
    private synchronized void setupResourceInfo(String name) {
1325
        if (name == null) {
1326
            return;
1327
        }
1328
        ResourceBundle rb = findResourceBundle(name);
1329
        if (rb == null) {
1330
            // We've failed to find an expected ResourceBundle.
1331
            throw new MissingResourceException("Can't find " + name + " bundle", name, "");
1332
        }
1333
        resourceBundleName = name;
1334
    }

    
 Return the parent for this Logger.
 
 This method returns the nearest extant parent in the namespace.
 Thus if a Logger is called "a.b.c.d", and a Logger called "a.b"
 has been created but no logger "a.b.c" exists, then a call of
 getParent on the Logger "a.b.c.d" will return the Logger "a.b".
 

 The result will be null if it is called on the root Logger
 in the namespace.

 
 Returns:nearest existing parent Logger
1348
1349
    public Logger getParent() {
1350
        synchronized (treeLock) {
1351
            return parent;
1352
        }
1353
    }

    
 Set the parent for this Logger.  This method is used by
 the LogManager to update a Logger when the namespace changes.
 
 It should not be called from application code.
 

 
 Parameters:parent   the new parent logger Throws:java.lang.SecurityException  if a security manager exists and if
             the caller does not have LoggingPermission("control").
1364
1365
    public void setParent(Logger parent) {
1366
        if (parent == null) {
1367
            throw new NullPointerException();
1368
        }
1369
        manager.checkAccess();
1370
        doSetParent(parent);
1371
    }
1372
1373
    // Private method to do the work for parenting a child
1374
    // Logger onto a parent logger.
1375
    private void doSetParent(Logger newParent) {
1376
1377
        // System.err.println("doSetParent \"" + getName() + "\" \""
1378
        //                              + newParent.getName() + "\"");
1379
1380
        synchronized (treeLock) {
1381
1382
            // Remove ourself from any previous parent.
1383
            if (parent != null) {
1384
                // assert parent.kids != null;
1385
                for (Iterator<WeakReference<Logger>> iter = parent.kids.iterator(); iter.hasNext(); ) {
1386
                    WeakReference<Logger> ref =  iter.next();
1387
                    Logger kid =  ref.get();
1388
                    if (kid == this) {
1389
                        iter.remove();
1390
                        break;
1391
                    }
1392
                }
1393
                // We have now removed ourself from our parents' kids.
1394
            }
1395
1396
            // Set our new parent.
1397
            parent = newParent;
1398
            if (parent.kids == null) {
1399
                parent.kids = new ArrayList<WeakReference<Logger>>(2);
1400
            }
1401
            parent.kids.add(new WeakReference<Logger>(this));
1402
1403
            // As a result of the reparenting, the effective level
1404
            // may have changed for us and our children.
1405
            updateEffectiveLevel();
1406
1407
        }
1408
    }
1409
1410
    // Recalculate the effective level for this node and
1411
    // recursively for our children.
1412
1413
    private void updateEffectiveLevel() {
1414
        // assert Thread.holdsLock(treeLock);
1415
1416
        // Figure out our current effective level.
1417
        int newLevelValue;
1418
        if (levelObject != null) {
1419
            newLevelValue = levelObject.intValue();
1420
        } else {
1421
            if (parent != null) {
1422
                newLevelValue = parent.levelValue;
1423
            } else {
1424
                // This may happen during initialization.
1425
                newLevelValue = Level.INFO.intValue();
1426
            }
1427
        }
1428
1429
        // If our effective value hasn't changed, we're done.
1430
        if (levelValue == newLevelValue) {
1431
            return;
1432
        }
1433
1434
        levelValue = newLevelValue;
1435
1436
        // System.err.println("effective level: \"" + getName() + "\" := " + level);
1437
1438
        // Recursively update the level on each of our kids.
1439
        if (kids != null) {
1440
            for (int i = 0; i < kids.size(); i++) {
1441
                WeakReference<Logger> ref = kids.get(i);
1442
                Logger kid =  ref.get();
1443
                if (kid != null) {
1444
                    kid.updateEffectiveLevel();
1445
                }
1446
            }
1447
        }
1448
    }
1449
1450
1451
    // Private method to get the potentially inherited
1452
    // resource bundle name for this Logger.
1453
    // May return null
1454
    private String getEffectiveResourceBundleName() {
1455
        Logger target = this;
1456
        while (target != null) {
1457
            String rbn = target.getResourceBundleName();
1458
            if (rbn != null) {
1459
                return rbn;
1460
            }
1461
            target = target.getParent();
1462
        }
1463
        return null;
1464
    }
1465
1466
1467
}