public TreeProcessor() 
{
            
        this.checkReload = true;
        this.lastModifiedDelay = 1000;
}

Create a TreeProcessor.

 protected TreeProcessor(TreeProcessor parent,
    ComponentManager manager) 
{
        this.parent = parent;
        // Copy all that can be copied from the parent
        this.enableLogging(parent.getLogger());
        this.context = parent.context;
        this.roleManager = parent.roleManager;
        this.builderSelector = parent.builderSelector;
        this.checkReload = parent.checkReload;
        this.lastModifiedDelay = parent.lastModifiedDelay;
        // We have our own CM
        this.manager = manager;
}

Create a child processor for a given language

 public ProcessingPipeline buildPipeline(Environment environment) throws Exception 
{
    		this.setupConcreteProcessor(environment);
    		return this.concreteProcessor.buildPipeline(environment);
}

Process the given Environment to assemble a ProcessingPipeline.

 public  void compose(ComponentManager manager) throws ComponentException 
{
        this.manager = manager;
        this.resolver = (SourceResolver)this.manager.lookup(SourceResolver.ROLE);
}

 public  void configure(Configuration config) throws ConfigurationException 
{
        this.checkReload = config.getAttributeAsBoolean("check-reload", true);
        // Obtain the configuration file, or use the XCONF_URL if none
        // is defined
        String xconfURL = config.getAttribute("config", XCONF_URL);
        // Reload check delay. Default is 1 second.
        this.lastModifiedDelay = config.getChild("reload").getAttributeAsLong("delay", 1000L);
        String fileName = config.getAttribute("file", "sitemap.xmap");
        try {
            this.source = new DelayedRefreshSourceWrapper(this.resolver.resolveURI(fileName), this.lastModifiedDelay);
        } catch (Exception e) {
            throw new ConfigurationException("Cannot resolve " + fileName, e);
        }
        // Read the builtin languages definition file
        Configuration builtin;
        try {
            Source source = this.resolver.resolveURI(xconfURL);
            try {
                Settings settings = SettingsHelper.getSettings(this.context);
                SAXConfigurationHandler handler = new PropertyAwareSAXConfigurationHandler(settings, this.getLogger());
                SourceUtil.toSAX( this.manager, source, null, handler);
                builtin = handler.getConfiguration();
            } finally {
                this.resolver.release(source);
            }
        } catch(Exception e) {
            String msg = "Error while reading " + xconfURL + ": " + e.getMessage();
            throw new ConfigurationException(msg, e);
        }
        // Create a selector for tree builders of all languages
        this.builderSelector = new ExtendedComponentSelector(Thread.currentThread().getContextClassLoader());
        try {
            LifecycleHelper.setupComponent(this.builderSelector,
                                           this.getLogger(),
                                           this.context,
                                           this.manager,
                                           this.roleManager,
                                           builtin);
        } catch (ConfigurationException e) {
            throw e;
        } catch (Exception e) {
            throw new ConfigurationException("Could not setup builder selector", e);
        }
}

 public  void contextualize(Context context) throws ContextException 
{
        this.context = context;
}

 public TreeProcessor createChildProcessor(ComponentManager manager,
    String actualSource,
    boolean checkReload) throws Exception 
{
        // Note: lifecycle methods aren't called, since this constructors copies all
        // that can be copied from the parent (see above)
        TreeProcessor child = new TreeProcessor(this, manager);
        child.checkReload = checkReload;
        child.resolver = (SourceResolver)manager.lookup(SourceResolver.ROLE);
        child.source = new DelayedRefreshSourceWrapper(child.resolver.resolveURI(actualSource), this.lastModifiedDelay);
        return child;
}

Create a new child of this processor (used for mounting submaps).

 public  void dispose() 
{
        // Dispose the concrete processor. No need to check for existing requests, as there
        // are none when a TreeProcessor is disposed.
        ContainerUtil.dispose(this.concreteProcessor);
        this.concreteProcessor = null;
        if (this.manager != null) {
	        if (this.source != null) {
	            this.resolver.release(this.source.getSource());
	            this.source = null;
	        }
            if (this.parent == null) {
                // root processor : dispose the builder selector
                this.builderSelector.dispose();
                this.builderSelector = null;
            }
            // Release resolver looked up in compose()
            this.manager.release((Component)this.resolver);
            this.resolver = null;
            this.manager = null;
	    }
}

 public Map getComponentConfigurations() 
{
        return this.concreteProcessor.getComponentConfigurations();
}

 public Processor getRootProcessor() 
{
        TreeProcessor result = this;
        while(result.parent != null) {
            result = result.parent;
        }
        return result;
}

 public boolean process(Environment environment) throws Exception 
{
        this.setupConcreteProcessor(environment);
        return this.concreteProcessor.process(environment);
}

Process the given Environment producing the output.

 public  void setComponentConfigurations(Configuration componentConfigurations) 
{
        this.concreteProcessor.setComponentConfigurations(componentConfigurations);
}

Set the sitemap component configurations

 public  void setRoleManager(RoleManager rm) 
{
        this.roleManager = rm;
}

 public String toString() 
{
        return "TreeProcessor - " + (this.source == null ? "[unknown location]" : this.source.getURI());
}