public Hierarchy(Logger root) 
{
                          
    ht = new Hashtable();
    listeners = new Vector(1);
    this.root = root;
    // Enable all level levels by default.
    setThreshold(Level.ALL);
    this.root.setHierarchy(this);
    rendererMap = new RendererMap();
    defaultFactory = new DefaultCategoryFactory();
}

Create a new logger hierarchy.

Parameters:

root - The root of the new hierarchy.

 public  void addHierarchyEventListener(HierarchyEventListener listener) 
{
    if(listeners.contains(listener)) {
      LogLog.warn("Ignoring attempt to add an existent listener.");
    } else {
      listeners.addElement(listener);
    }
}

 public  void addRenderer(Class classToRender,
    ObjectRenderer or) 
{
    rendererMap.put(classToRender, or);
}

Add an object renderer for a specific class.

 public  void clear() 
{
    //System.out.println("\n\nAbout to clear internal hash table.");
    ht.clear();
}

This call will clear all logger definitions from the internal hashtable. Invoking this method will irrevocably mess up the logger hierarchy.

You should really know what you are doing before invoking this method.

 public  void emitNoAppenderWarning(Category cat) 
{
    // No appenders in hierarchy, warn user only once.
    if(!this.emittedNoAppenderWarning) {
      LogLog.warn("No appenders could be found for logger (" +
		   cat.getName() + ").");
      LogLog.warn("Please initialize the log4j system properly.");
      this.emittedNoAppenderWarning = true;
    }
}

 public Logger exists(String name) 
{
    Object o = ht.get(new CategoryKey(name));
    if(o instanceof Logger) {
      return (Logger) o;
    } else {
      return null;
    }
}

Check if the named logger exists in the hierarchy. If so return its reference, otherwise returns null.

 public  void fireAddAppenderEvent(Category logger,
    Appender appender) 
{
    if(listeners != null) {
      int size = listeners.size();
      HierarchyEventListener listener;
      for(int i = 0; i <  size; i++) {
	listener = (HierarchyEventListener) listeners.elementAt(i);
	listener.addAppenderEvent(logger, appender);
      }
    }
}

  void fireRemoveAppenderEvent(Category logger,
    Appender appender) 
{
    if(listeners != null) {
      int size = listeners.size();
      HierarchyEventListener listener;
      for(int i = 0; i <  size; i++) {
	listener = (HierarchyEventListener) listeners.elementAt(i);
	listener.removeAppenderEvent(logger, appender);
      }
    }
}

 public Enumeration getCurrentCategories() 
{
    return getCurrentLoggers();
}

 public Enumeration getCurrentLoggers() 
{
    // The accumlation in v is necessary because not all elements in
    // ht are Logger objects as there might be some ProvisionNodes
    // as well.
    Vector v = new Vector(ht.size());
    Enumeration elems = ht.elements();
    while(elems.hasMoreElements()) {
      Object o = elems.nextElement();
      if(o instanceof Logger) {
	v.addElement(o);
      }
    }
    return v.elements();
}

Returns all the currently defined categories in this hierarchy as an Enumeration .

The root logger is not included in the returned Enumeration .

 public Logger getLogger(String name) 
{
    return getLogger(name, defaultFactory);
}

Return a new logger instance named as the first parameter using the default factory.

If a logger of that name already exists, then it will be returned. Otherwise, a new logger will be instantiated and then linked with its existing ancestors as well as children.

 public Logger getLogger(String name,
    LoggerFactory factory) 
{
    //System.out.println("getInstance("+name+") called.");
    CategoryKey key = new CategoryKey(name);
    // Synchronize to prevent write conflicts. Read conflicts (in
    // getChainedLevel method) are possible only if variable
    // assignments are non-atomic.
    Logger logger;
    synchronized(ht) {
      Object o = ht.get(key);
      if(o == null) {
	logger = factory.makeNewLoggerInstance(name);
	logger.setHierarchy(this);
	ht.put(key, logger);
	updateParents(logger);
	return logger;
      } else if(o instanceof Logger) {
	return (Logger) o;
      } else if (o instanceof ProvisionNode) {
	//System.out.println("("+name+") ht.get(this) returned ProvisionNode");
	logger = factory.makeNewLoggerInstance(name);
	logger.setHierarchy(this);
	ht.put(key, logger);
	updateChildren((ProvisionNode) o, logger);
	updateParents(logger);
	return logger;
      }
      else {
	// It should be impossible to arrive here
	return null;  // but let's keep the compiler happy.
      }
    }
}

Return a new logger instance named as the first parameter using factory.

If a logger of that name already exists, then it will be returned. Otherwise, a new logger will be instantiated by the factory parameter and linked with its existing ancestors as well as children.

 public RendererMap getRendererMap() 
{
    return rendererMap;
}

Get the renderer map for this hierarchy.

 public Logger getRootLogger() 
{
    return root;
}

Get the root of this hierarchy.

 public Level getThreshold() 
{
    return threshold;
}

Returns a Level representation of the enable state.

 public boolean isDisabled(int level) 
{
    return thresholdInt  > level;
}

This method will return true if this repository is disabled for level object passed as parameter and false otherwise. See also the threshold emthod.

 public  void overrideAsNeeded(String override) 
{
    LogLog.warn("The Hiearchy.overrideAsNeeded method has been deprecated.");
}

 public  void resetConfiguration() 
{
    getRootLogger().setLevel((Level) Level.DEBUG);
    root.setResourceBundle(null);
    setThreshold(Level.ALL);
    // the synchronization is needed to prevent JDK 1.2.x hashtable
    // surprises
    synchronized(ht) {
      shutdown(); // nested locks are OK
      Enumeration cats = getCurrentLoggers();
      while(cats.hasMoreElements()) {
	Logger c = (Logger) cats.nextElement();
	c.setLevel(null);
	c.setAdditivity(true);
	c.setResourceBundle(null);
      }
    }
    rendererMap.clear();
}

Reset all values contained in this hierarchy instance to their default. This removes all appenders from all categories, sets the level of all non-root categories to null, sets their additivity flag to true and sets the level of the root logger to DEBUG . Moreover, message disabling is set its default "off" value.

Existing categories are not removed. They are just reset.

This method should be used sparingly and with care as it will block all logging until it is completed.

 public  void setDisableOverride(String override) 
{
    LogLog.warn("The Hiearchy.setDisableOverride method has been deprecated.");
}

Does mothing.

 public  void setRenderer(Class renderedClass,
    ObjectRenderer renderer) 
{
    rendererMap.put(renderedClass, renderer);
}

Used by subclasses to add a renderer to the hierarchy passed as parameter.

 public  void setThreshold(String levelStr) 
{
    Level l = (Level) Level.toLevel(levelStr, null);
    if(l != null) {
      setThreshold(l);
    } else {
      LogLog.warn("Could not convert ["+levelStr+"] to Level.");
    }
}

The string form of #setThreshold(Level) .

 public  void setThreshold(Level l) 
{
    if(l != null) {
      thresholdInt = l.level;
      threshold = l;
    }
}

Enable logging for logging requests with level l or higher. By default all levels are enabled.

 public  void shutdown() 
{
    Logger root = getRootLogger();
    // begin by closing nested appenders
    root.closeNestedAppenders();
    synchronized(ht) {
      Enumeration cats = this.getCurrentLoggers();
      while(cats.hasMoreElements()) {
	Logger c = (Logger) cats.nextElement();
	c.closeNestedAppenders();
      }
      // then, remove all appenders
      root.removeAllAppenders();
      cats = this.getCurrentLoggers();
      while(cats.hasMoreElements()) {
	Logger c = (Logger) cats.nextElement();
	c.removeAllAppenders();
      }
    }
}

Shutting down a hierarchy will safely close and remove all appenders in all categories including the root logger.

Some appenders such as org.apache.log4j.net.SocketAppender and AsyncAppender need to be closed before the application exists. Otherwise, pending logging events might be lost.

The shutdown method is careful to close nested appenders before closing regular appenders. This is allows configurations where a regular appender is attached to a logger and again to a nested appender.