mwomack 2003/06/10 22:57:14
Modified: src/java/org/apache/log4j/helpers LoggerTraverse.java
Log:
Jalopy-ized, checkstyle'd version.
Revision Changes Path
1.2 +119 -85
jakarta-log4j-sandbox/src/java/org/apache/log4j/helpers/LoggerTraverse.java
Index: LoggerTraverse.java
===================================================================
RCS file:
/home/cvs/jakarta-log4j-sandbox/src/java/org/apache/log4j/helpers/LoggerTraverse.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- LoggerTraverse.java 11 Jun 2003 05:39:16 -0000 1.1
+++ LoggerTraverse.java 11 Jun 2003 05:57:14 -0000 1.2
@@ -49,140 +49,151 @@
package org.apache.log4j.helpers;
-import java.util.Map;
-import java.util.TreeMap;
-import java.util.List;
+import org.apache.log4j.Level;
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Logger;
+import org.apache.log4j.spi.LoggerRepository;
+
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
-import org.apache.log4j.Logger;
-import org.apache.log4j.LogManager;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggerRepository;
/**
- This helper class can be used to extract/traverse logger information
- for a given LoggerRepository. It is a work in progress and focus to
+ This helper class can be used to extract/traverse logger information
+ for a given LoggerRepository. It is a work in progress and focus to
date has been functionality, not performance or efficiency.
-
+
The set of loggers can be retrieved in one of two ways:
-
+
1) getLoggerNames() - A complete list of the loggers
2) getLoggerPackageNames() - A list of package names, starting at a
given package name pattern.
-
+
If the second retrieval method is used, the caller can iteratively call
the LoggerTraverse to retrieve sub-packages and children.
-
+
This class is dependent on logger names that match Java fully qualified
class names.
-
+
It also provides methods for querying the current level of a given
- logger and
-
+ logger and
+
NOTE: This class does not cause any side effects in the LoggerRepository.
It does not inadvertantly create new Loggers in the process of parsing the
package names or accessing information.
-
+
NOTE: This class does not automatically keep track of changes in the given
LoggerRepository. The caller must call the update() method to get the
current set of loggers.
-
+
@author Mark Womack <[EMAIL PROTECTED]>
*/
public class LoggerTraverse {
+ /** A map of all the loggers in the LoggerRepository. */
private Map loggerMap = new TreeMap();
- private Logger rootLogger;
+ /** A reference to the root logger of the LoggerRepository. */
+ private Logger rootLogger;
+
+ /**
+ Empty constructor. */
public LoggerTraverse() {
}
-
+
+ /**
+ @param repository The LoggerRepository to traverse. */
public LoggerTraverse(LoggerRepository repository) {
update(repository);
}
-
+
/**
Updates the LoggerTraverse to the current information in the given
LoggerRepository.
-
- @param respository LoggerRepository to use for Logger information. */
+
+ @param repository LoggerRepository to use for Logger information. */
public void update(LoggerRepository repository) {
// clear any old information
loggerMap.clear();
-
+
// set the root logger
rootLogger = repository.getRootLogger();
-
+
// enumerate through the current set of loggers
// the key is the logger name, the value is the logger
Enumeration loggerEnum = repository.getCurrentLoggers();
+
while (loggerEnum.hasMoreElements()) {
- Logger logger = (Logger)loggerEnum.nextElement();
+ Logger logger = (Logger) loggerEnum.nextElement();
loggerMap.put(logger.getName(), logger);
}
}
-
+
/**
- Returns the list of all loggers, sorted by name.
-
+ Returns the list of all loggers, sorted by name.
+
@return List List of the current loggers. */
public List getLoggerNames() {
List loggerList = new ArrayList(loggerMap.size());
Iterator loggerIter = loggerMap.keySet().iterator();
+
while (loggerIter.hasNext()) {
- loggerList.add((String)loggerIter.next());
+ loggerList.add((String) loggerIter.next());
}
+
return loggerList;
}
-
+
/**
Using a starting name pattern, returns the next level of package names
that start with that pattern. Returns a list, as there can be more than
one return value. Passing in an empty string for the starting pattern
will return a list of the top level package names.
-
+
For example, if the following logger names were defined: org.apache.log4j
and org.apache.log4j-extensions, then passing in an empty string would
return one item in the list with a value of "org". If the pattern
"org.apache" were passed in, then the list would contain two items,
"log4j" and "log4j-extensions".
-
- @param startPattern The name pattern to match for Logger name.
+
+ @param startPattern The name pattern to match for Logger name.
@return List List of matching Logger names that start with the pattern. */
public List getLoggerPackageNames(String startPattern) {
String name = "";
List packageList = new ArrayList(1);
-
+
// iterate through the loggerMap, checking the name of each logger
// against the starting pattern. If name starts with pattern, then
// add the next part of the package name to the return list.
Iterator loggerIter = loggerMap.keySet().iterator();
+
while (loggerIter.hasNext()) {
- String loggerName = (String)loggerIter.next();
-
+ String loggerName = (String) loggerIter.next();
+
// does the logger name start with the startPattern
if (loggerName.startsWith(startPattern)) {
loggerName = loggerName.substring(startPattern.length());
-
+
// is there part of the name left after the start pattern is removed?
if (loggerName.length() > 0) {
-
// if the left over string starts with '.'. remove it
if (loggerName.startsWith(".")) {
loggerName = loggerName.substring(1);
- }
- else if (startPattern.length() > 0) {
+ } else if (startPattern.length() > 0) {
break;
}
-
+
// find the next index of '.' and grab the part of the name before it
int index = loggerName.indexOf('.');
+
if (index != -1) {
//System.out.println("found . at " + index);
loggerName = loggerName.substring(0, index);
}
-
+
// if this is not a name we have previously encountered,
// put it in the return list.
if (!loggerName.equals(name)) {
@@ -192,137 +203,160 @@
}
}
}
-
+
return packageList;
}
-
+
/**
Returns true if the given package name appears to have sub-package.
-
+
@param startPattern The name pattern to match for Logger name.
@return boolean True if there are existing loggers that match. */
public boolean loggerHasSubPackages(String startPattern) {
int len = startPattern.length();
-
+
// iterate through logger names and first one that starts with
// pattern and the length is greater, return true.
Iterator loggerIter = loggerMap.keySet().iterator();
+
while (loggerIter.hasNext()) {
- String loggerName = (String)loggerIter.next();
- if (loggerName.startsWith(startPattern) && loggerName.length() > len) {
+ String loggerName = (String) loggerIter.next();
+
+ if (loggerName.startsWith(startPattern) && (loggerName.length() > len)) {
return true;
}
}
-
+
return false;
}
/**
- Returns the level for the root logger.
-
+ Returns the level for the root logger.
+
@return Level The current Level for the root logger. */
public Level getLevelForRootLogger() {
return rootLogger.getEffectiveLevel();
}
-
+
/**
Returns the effective level for the given package name. If no level is
set for the given package, then search back through the package names
- until one is found that is set or return the level of the root logger.
-
+ until one is found that is set or return the level of the root logger.
+
@param packageName The name of the logger to return the level for.
@return Level The level of the logger. */
public Level getLevelForPackage(String packageName) {
String name = packageName;
- Logger logger = (Logger)loggerMap.get(packageName);
- while (logger == null && name != null) {
+ Logger logger = (Logger) loggerMap.get(packageName);
+
+ while ((logger == null) && (name != null)) {
int index = name.lastIndexOf('.');
+
if (index != -1) {
- name = name.substring(0, index-1);
- logger = (Logger)loggerMap.get(packageName);
+ name = name.substring(0, index - 1);
+ logger = (Logger) loggerMap.get(packageName);
} else {
name = null;
}
}
-
+
if (logger != null) {
return logger.getEffectiveLevel();
- }
- else {
+ } else {
return rootLogger.getEffectiveLevel();
}
}
/**
Returns true of the package has had its level set directly or
- false if the level is inherited.
-
+ false if the level is inherited.
+
@param packageName The name of the logger to return the level for.
@return boolean True if the level has been explicitly configured. */
public boolean getLevelIsSetForPackage(String packageName) {
String name = packageName;
- Logger logger = (Logger)loggerMap.get(packageName);
- while (logger == null && name != null) {
+ Logger logger = (Logger) loggerMap.get(packageName);
+
+ while ((logger == null) && (name != null)) {
int index = name.lastIndexOf('.');
+
if (index != -1) {
- name = name.substring(0, index-1);
- logger = (Logger)loggerMap.get(packageName);
+ name = name.substring(0, index - 1);
+ logger = (Logger) loggerMap.get(packageName);
} else {
name = null;
}
}
-
+
if (logger != null) {
- if (logger == rootLogger)
+ if (logger == rootLogger) {
return true;
- else
+ } else {
return (logger.getLevel() != null);
+ }
} else {
return false;
}
}
-
- // here is an example of using the hierarchical version, iterating
- // through all the package names, all the loggers.
- public static void main(String[] args) {
+
+ /**
+ here is an example of using the hierarchical version, iterating
+ through all the package names, all the loggers.
+ @param args Parameters for main execution. */
+ public static void main(String[] args) {
// set the root to level warn
Logger.getRootLogger().setLevel(Level.ERROR);
-
+
// create some loggers
Logger.getLogger("org.womacknet.wgntool.Researcher");
Logger.getLogger("org.womacknet.wgntool.ResearcherList");
Logger.getLogger("org.womacknet.wgntool").setLevel(Level.WARN);
Logger.getLogger("org.womacknet.util.NameUtil");
Logger.getLogger("com.widgets_r_us.util.StringUtil").setLevel(Level.DEBUG);
-
+
LoggerTraverse info = new LoggerTraverse(LogManager.getLoggerRepository());
- System.out.println("NOTE: '*' indicates the level has not been explicitly
configured for that logger");
+ System.out.println("NOTE: '*' indicates the level has not been "
+ + "explicitly configured for that logger");
System.out.println("root - " + info.getLevelForRootLogger());
iteratePackages("", 1, info);
}
-
- // starting with a package name, iterate through all subpackages and loggers.
- static void iteratePackages(String startPackageName, int level, LoggerTraverse
info) {
+
+ /**
+ Starting with a package name, iterate through all subpackages and loggers.
+
+ @param startPackageName The logger name to start iterating from.
+ @param level The indentation value for display of logger names.
+ @param info The TraverseInfo instance to iterate. */
+ static void iteratePackages(
+ String startPackageName, int level, LoggerTraverse info) {
List packageInfo = info.getLoggerPackageNames(startPackageName);
Iterator iter = packageInfo.iterator();
+
while (iter.hasNext()) {
- String packageName = (String)iter.next();
+ String packageName = (String) iter.next();
+
for (int x = 0; x < level; x++) {
System.out.print(" ");
}
+
System.out.print(packageName);
+
String subpackageName;
+
if (startPackageName.length() > 0) {
subpackageName = startPackageName + "." + packageName;
} else {
subpackageName = packageName;
}
+
System.out.print(" - " + info.getLevelForPackage(subpackageName));
- System.out.println((info.getLevelIsSetForPackage(subpackageName) ? "" : "*"));
+ System.out.println(
+ (info.getLevelIsSetForPackage(subpackageName) ? "" : "*"));
+
if (info.loggerHasSubPackages(subpackageName)) {
- iteratePackages(subpackageName, level+1, info);
+ iteratePackages(subpackageName, level + 1, info);
}
}
}
-}
\ No newline at end of file
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
