String[] parts = name.split("\\/");
    int depth = 0;
    ScanNode parentNode = rootNode;

    // create any missing directory nodes.
    for( int i = 0; i < parts.length - 1; i++ ) {
      ScanNode currNode = parentNode.getChildMap().get(parts[i]);
      if( currNode == null ) {
        currNode = new ScanNode();
        currNode.setResourceName("".equals(parentNode.getResourceName())?parts[i]:parentNode.getResourceName()+"/"+parts[i]);
        currNode.setName(parts[i]);
        currNode.setDirectory(true);
        currNode.setFile(false);
        parentNode.getChildMap().put(parts[i], currNode);
      }
      else {
        currNode.setDirectory(true);
      }
      parentNode = currNode;
    }

    // ASSERT: parentNode is now the parent node of this entry.

    // create the entry node if it is not already in the scan tree.
    ScanNode currNode = parentNode.getChildMap().get(parts[parts.length-1]);
    if( currNode == null ) {
      currNode = new ScanNode();
      currNode.setResourceName("".equals(parentNode.getResourceName())?parts[parts.length-1]:parentNode.getResourceName()+"/"+parts[parts.length-1]);
      currNode.setName(parts[parts.length-1]);
      currNode.setDirectory(isDirectory(name)?true:false);

  }

  public void scanNode( ScanNode node )
    throws ScanException
  {
    try {
      if( isLoadableClassFile(node.getResourceName()) ) {
        String className = toClassName(node);

        CtClass scannedCtClass = null;
        boolean requiresAnnotationScanning = false;

        try {
          scannedCtClass = classPool.get(className);
          requiresAnnotationScanning = hasAnnotation(scannedCtClass, LifecycleClass.class);
        }
        catch( Exception e ) {
          if( log.isDebugEnabled() ) {
            log.debug("Could not scan file '"+node.getResourceName()+"' due to an exception.", e);
          }
          return;
        }
        if( requiresAnnotationScanning ) {
          // get the actual class.
          Class lifecycleClass = context.getClassLoader().loadClass(className);

          // get the lifecycle annotation.
          LifecycleClass lifecycleAnnotation = (LifecycleClass)lifecycleClass.getAnnotation(LifecycleClass.class);
          
          // get the uri for the annotations found in the class.
          String namespaceUri = lifecycleAnnotation.uri();

          // scan the lifecycle class for a lifecycle accessor method.
          Method accessorMethod = null;
          int accessorMethodCount = 0;
          for( Method method : lifecycleClass.getDeclaredMethods() ) {
            if( Modifier.isStatic(method.getModifiers()) && hasAnnotation(method, LifecycleAccessor.class) ) {
              accessorMethod = method;
              accessorMethodCount++;
            }
          }

          if( accessorMethodCount > 1 ) {
            throw new ScanException("The class '"+lifecycleClass+"' has "+accessorMethodCount+" static methods that are annotated with the LifecycleAccessor annotation."+
                     " Lifecycle classes should have at most one accessor method.");
          }

          // scan the class for for start and stop steps.
          for( Method method : lifecycleClass.getMethods() ) {
            boolean isStartStep = hasAnnotation(method, StartStep.class);

  protected Serializer newSerializer()
  {
    Properties outputProperties = OutputPropertiesFactory.getDefaultMethodProperties( method );

    if ( method.toLowerCase().equals("html") ) {
      if (indent == null) indent = true; // default to indenting mode
      outputProperties.setProperty( "media-type", "text/html" );
      outputProperties.setProperty( "doctype-system", "http://www.w3.org/TR/html4/loose.dtd" );
      outputProperties.setProperty( "doctype-public", "-//W3C//DTD HTML 4.01 Transitional//EN" );
    }
    else if ( method.toLowerCase().equals("xhtml") ) {
      if (indent == null) indent = true; // default to indenting mode
      outputProperties.setProperty( "media-type", "application/xhtml+xml" );
      outputProperties.setProperty( "omit-xml-declaration", "yes" ); // todo: should be browser sensitive
      outputProperties.setProperty( "doctype-system", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" );
      outputProperties.setProperty( "doctype-public", "-//W3C//DTD XHTML 1.0 Transitional//EN" );
    }
    else if ( method.toLowerCase().equals("xml") ) {
      outputProperties.setProperty( "media-type", "text/xml" );
    }
    else if ( method.toLowerCase().equals("text") ) {
      outputProperties.setProperty( "media-type", "text/plain" );
    }

    if ( Boolean.TRUE.equals( indent )) {
      outputProperties.setProperty( "indent", "yes" );
      outputProperties.setProperty( "{http://xml.apache.org/xalan}indent-amount", "2" );
    }
    else {
      outputProperties.setProperty( "indent", "no" );
    }

    try {

    }
    else if( inProlog ) {
      // cache the processing instruction.
      eventList.add(new ProcessingInstructionEvent(target, data));
    }
    else {
      super.processingInstruction(target, data);
    }
  }

  /**
   * Caches notation decl events until the prolog is finished.
   */
  public void notationDecl(String name, String publicId, String systemId)
    throws SAXException
  {
    if( inProlog ) {
      eventList.add(new NotationDeclEvent(name, publicId, systemId));
    }
    else {
      super.notationDecl(name, publicId, systemId);
    }
  }

  /**
   * Caches unparsed entity decl events until the prolog is finished.
   */
  public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName)
    throws SAXException
  {
    if( inProlog ) {
      eventList.add(new UnparsedEntityDeclEvent(name, publicId, systemId, notationName));
    }
    else {
      super.unparsedEntityDecl(name, publicId, systemId, notationName);
    }
  }

  /**
   * If this start element is the end of the prolog, then endProlog() is called.  Then start
   * elements are passed along.
   */
  public void startElement( String uri, String localName, String qName, Attributes attributes )
    throws SAXException
  {
    if( inProlog ) {
      endProlog();

    ListIterator<Command> iterator = commandList.listIterator();
    while( iterator.hasNext() ) {
      try {
         saveResult = iterator.next().execute(context);
         if (saveResult) {
           break;
         }
      } catch (Exception e) {
         saveException = e;
         break;
      }
    }

    pushIterator(iterator);

    if( saveException != null ) {
      throw saveException;
    }

    return saveResult;
  }

  public boolean postProcess( JXPathContext context, Exception exception )
  {
    ListIterator<Command> iterator = popIterator();

    boolean handled = false;
    boolean result = false;
    while( iterator.hasPrevious() ) {
      Command previous = iterator.previous();
      if (previous instanceof Filter) {
         try {
           result = ((Filter) previous).postProcess(context, exception);
           if (result) {
             handled = true;
           }
         }
         catch (Exception e) {
           // Silently ignore
         }
      }
    }
    return handled;
  }

      throw new SAXException("Unknown template element '{"+uri+"}"+localName+"'.");
    }

    if( startSource ) {
      // send start prefix mapping events to the digester.
      for( Map.Entry<String, String> mapping : elementInfoStack.getFirst().getHandlerPrefixMapping().entrySet() ) {
        getContentHandler().startPrefixMapping(mapping.getKey(), mapping.getValue());
      }

      // create a new attributes object with any attributes that are in an xchain namespace.
      AttributesImpl digesterAttributes = new AttributesImpl();
      for( int i = 0; i < attributes.getLength(); i++ ) {
        if( commandNamespaceSet.contains(attributes.getURI(i)) ) {
          digesterAttributes.addAttribute(attributes.getURI(i), attributes.getLocalName(i), attributes.getQName(i), attributes.getType(i), attributes.getValue(i));
        }
      }

      // send the start template element to the digester.
      getContentHandler().startElement( JSL_NAMESPACE, TEMPORARY_CHAIN_LOCAL_NAME, temporaryChainQName(), digesterAttributes );
    }
  }

    ListIterator<Command> iterator = commandList.listIterator();
    while( iterator.hasNext() ) {
      try {
         saveResult = iterator.next().execute(context);
         if (saveResult) {
           break;
         }
      } catch (Exception e) {
         saveException = e;
         break;
      }
    }

    boolean handled = false;
    boolean result = false;
    while( iterator.hasPrevious() ) {
      Object previous = iterator.previous();
      if (previous instanceof Filter) {
         try {
           result = ((Filter) previous).postProcess(context, saveException);
           if (result) {
             handled = true;
           }
         }
         catch (Exception e) {
           // Silently ignore
         }
      }
    }

    // Return the exception or result state from the last execute()
    if ((saveException != null) && !handled) {
      throw saveException;
    }
    else {
      return (saveResult);
    }
  }

		if (level.toLowerCase().equals("trace")) {
			log.trace(buffer.toString());
		}
		if (level.toLowerCase().equals("debug")) {
			log.debug(buffer.toString());
		}
		if (level.toLowerCase().equals("info")) {
			log.info(buffer.toString());
		}
		if (level.toLowerCase().equals("warn")) {
			log.warn(buffer.toString());
		}
		if (level.toLowerCase().equals("error")) {
			log.error(buffer.toString());
		}

  AnnotationLifecycleStep(QName qName) {
    this();
    this.setQName(qName);
  }

  /**
   * <p>Sets the QName for this step.</p>
   */
  public void setQName(QName qName) { this.qName = qName; }
  /**
   * <p>Returns the QName for this step.</p>
   */
  public QName getQName() { return this.qName; }
  /**
   * <p>Sets the start method for this annotated lifecycle step.  The method set should take at most one argument of type LifecycleContext.</p>
   */
  public void setStartMethod( Method startMethod ) { this.startMethod = startMethod; }
  /**
   * <p>Returns the start method.</p>
   */
  public Method getStartMethod() { return this.startMethod; }
  /**
   * <p>Sets the start method for this annotated lifecycle step.  The method set should take at most one argument of type LifecycleContext.</p>
   */
  public void setStopMethod( Method stopMethod ) { this.stopMethod = stopMethod; }
  /**
   * <p>Returns the stop method for this annotated lifecycle step.</p>
   */
  public Method getStopMethod() { return this.stopMethod; }
  /**
   * <p>Sets the method for accessing the lifecycle class instance. LifecycleAccessor methods must be static and take zero arguments.  If either the start method or the stop methods is an
   * instance method, then this method must be defined.</p>
   */
  public void setLifecycleAccessor( Method lifecycleAccessor ) { this.lifecycleAccessor = lifecycleAccessor; }
  /**
   * <p>Returns the method for accessing the lifecycle class instance.</p>
   */
  public Method getLifecycleAccessor() { return this.lifecycleAccessor; }
  /**
   * <p>Sets the prefix mappings to use with the DocumentConfigContext for the start method. This should be a mapping of xml prefixes to valid namespaces.</p>
   */
  public void setStartMethodPrefixMappings(Map<String, String> prefixMappings) { this.prefixMappings = prefixMappings; }

      }
    }

    /**
     * Finds the catalog that is closest to the top of the digesters stack.
     */
    protected Catalog findCatalogInStack()
    {
      Catalog catalog = null;

      if( log.isDebugEnabled() ) {
        log.debug("digester.getCount() = "+digester.getCount());
      }

      for( int i = 0; i < digester.getCount() && catalog == null; i++ ) {
        Object peeked = digester.peek(i);

        if( log.isDebugEnabled() ) {
          log.debug("Looking for catalog in digester stack at index "+i+".  Found object of type '"+peeked.getClass().getName()+"'.");
        }

        if( peeked instanceof Catalog ) {
          catalog = (Catalog)peeked;
        }
      }

      return catalog;
    }
  }

  public boolean execute( JXPathContext context )
    throws Exception
  {
    QName variableName = getName(context);
    Object variableValue = null;

    if( hasSelect() ) {
      variableValue = getSelect(context);
    }
    else if( hasSelectNodes() ) {
      variableValue = getSelectNodes(context);
    }
    else if( hasSelectSingleNode() ) {
      variableValue = getSelectSingleNode(context);
    }
    else {
      throw new Exception( "Variable '"+variableName+"' must have a select attribute (select, select-nodes, or select-single-node)" );
    }

    // get the scope.
    Scope scope = getScope(context);

    if( log.isDebugEnabled() ) {
      log.debug("Setting variable name '"+variableName+"' to value '"+variableValue+"' in scope '"+scope+"'.");
    }

  }

  private static Set<QName> toQNameSet( String[] qNameArray, String defaultUri )
    throws ScanException
  {
    Set<QName> qNameSet = new HashSet<QName>();
    for( String qNameString : qNameArray ) {
      QName qName = null;
      if( qNameString.startsWith("{") ) {
        qName = QName.valueOf(qNameString);
      }
      else if( qNameString.matches("[A-Za-z][-A-Za-z0-9._]*") ) {
        qName = new QName( defaultUri, qNameString );
      }
      else {
        throw new ScanException("The qname string '"+qNameString+"' does not appear to be a valid qname or local name.");
      }
      qNameSet.add(qName);
    }
    return qNameSet;
  }
}