public PipelineNode(String name) 
{
        this.processingPipeline = name;
        this.errorHandlerHelper = new ErrorHandlerHelper();
}

A constructor to receive the optional expires parameter and optional parameters for the processing pipeline

 public  void compose(ComponentManager manager) 
{
        this.errorHandlerHelper.compose(manager);
}

The component manager is used to create error pipelines

 public  void enableLogging(Logger logger) 
{
        super.enableLogging(logger);
        this.errorHandlerHelper.enableLogging(logger);
}

 public final boolean invoke(Environment env,
    InvokeContext context) throws Exception 
{
        boolean passThrough;
        Object passThroughRaw = env.getAttribute(MountNode.COCOON_PASS_THROUGH);
        if (passThroughRaw == null) {
            // Use default value
            passThrough = false;
        } else {
            passThrough = ((Boolean) passThroughRaw).booleanValue();
        }
        // Always fail on external request if pipeline is internal only.
        if (this.internalOnly && env.isExternal()) {
            if (!this.isLast || passThrough) {
                return false;
            }
            // Do not use internal-only pipeline error handler for external requests.
            throw new ResourceNotFoundException("No pipeline matched request: " +
                                                env.getURIPrefix() + env.getURI());
        }
        context.inform(this.processingPipeline, this.parameters, env.getObjectModel());
        try {
            if (this.errorHandlerHelper.isInternal()) {
                // Set internal error handler in the pipeline
                context.setErrorHandler(
                        new SitemapErrorHandler(this.errorHandlerHelper, env, context));
            } else {
                // Reset internal error handler (previous pipeline might had set it) 
                context.setErrorHandler(null);
            }
            if (invokeNodes(children, env, context)) {
                return true;
            } else if (!this.isLast || passThrough) {
                return false;
            }
            throw new ResourceNotFoundException("No pipeline matched request: " +
                                                env.getURIPrefix() + env.getURI());
        } catch (ConnectionResetException e) {
            // Will be reported by CocoonServlet, rethrowing
            throw e;
        } catch (Exception e) {
            // Invoke error handler
            return this.errorHandlerHelper.invokeErrorHandler(e, env, context);
        }
}

 public  void set404Handler(ProcessingNode node) 
{
        this.errorHandlerHelper.set404Handler(node);
}

 public  void set500Handler(ProcessingNode node) 
{
        this.errorHandlerHelper.set500Handler(node);
}

 public  void setChildren(ProcessingNode[] nodes) 
{
        this.children = nodes;
}

 public  void setInternalOnly(boolean internalOnly) 
{
        this.internalOnly = internalOnly;
}

 public  void setLast(boolean isLast) 
{
        this.isLast = isLast;
}

 public  void setParameters(Map parameterMap) 
{
        this.parameters = parameterMap;
}