public AbstractInterpreter() 
{

}

 public  void configure(Configuration config) throws ConfigurationException 
{
        reloadScripts = config.getChild("reload-scripts").getValueAsBoolean(false);
        checkTime = config.getChild("check-time").getValueAsLong(1000L);
}

 public  void contextualize(Context context) throws ContextException 
{
        this.avalonContext = context;
        this.context = (Context)context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
}

 public  void dispose() 
{
        if ( this.manager != null ) {
            this.manager.release( this.continuationsMgr );
            this.continuationsMgr = null;
            this.manager = null;
        }
}

 public  void forwardTo(String uri,
    Object bizData,
    WebContinuation continuation,
    Redirector redirector) throws Exception 
{
        if (SourceUtil.indexOfSchemeColon(uri) == -1) {
            uri = "cocoon:/" + uri;
            Map objectModel = ContextHelper.getObjectModel(this.avalonContext);
            FlowHelper.setWebContinuation(objectModel, continuation);
            FlowHelper.setContextObject(objectModel, bizData);
            if (redirector.hasRedirected()) {
                throw new IllegalStateException("Pipeline has already been processed for this request");
            }
            // this is a hint for the redirector
            objectModel.put("cocoon:forward", "true");
            redirector.redirect(false, uri);
        } else {
            throw new Exception("uri is not allowed to contain a scheme (cocoon:/ is always automatically used)");
        }
}

 public String getInterpreterID() 
{
        return this.instanceID;
}

Get the unique ID for this interpreter, which can be used to distinguish user value scopes attached to the session.

 public  void process(String uri,
    Object biz,
    OutputStream out) throws Exception 
{
        // FIXME (SW): should we deprecate this method in favor of PipelineUtil?
        PipelineUtil pipeUtil = new PipelineUtil();
        try {
            pipeUtil.contextualize(this.avalonContext);
            pipeUtil.service(this.manager);
            pipeUtil.processToStream(uri, biz, out);
        } finally {
            pipeUtil.dispose();
        }
}

Call the Cocoon sitemap for the given URI, sending the output of the eventually matched pipeline to the specified outputstream.

 public  void register(String source) 
{
        synchronized (this) {
            needResolve.add(source);
        }
}

Registers a source file with the interpreter. Using this method an implementation keeps track of all the script files which are compiled. This allows them to reload the script files which get modified on the file system.

The parsing/compilation of a script file by an interpreter happens in two phases. In the first phase the file's location is registered in the needResolve array.

The second is possible only when a Cocoon Environment is passed to the Interpreter. This allows the file location to be resolved using Cocoon's SourceFactory class.

Once a file's location can be resolved, it is removed from the needResolve array and placed in the scripts hash table. The key in this hash table is the file location string, and the value is a DelayedRefreshSourceWrapper instance which keeps track of when the file needs to re-read.

 public  void service(ServiceManager sm) throws ServiceException 
{
        this.manager = sm;
        this.continuationsMgr = (ContinuationsManager)sm.lookup(ContinuationsManager.ROLE);
}

Serviceable

 public  void setInterpreterID(String interpreterID) 
{
        this.instanceID = interpreterID;
}

Set the unique ID for this interpreter, which can be used to distinguish user value scopes attached to the session.