sources/org/apache/batik/refimpl/script/ConcreteInterpreterPool.java

/*****************************************************************************
 * Copyright (C) The Apache Software Foundation. All rights reserved.        *
 * ------------------------------------------------------------------------- *
 * This software is published under the terms of the Apache Software License *
 * version 1.1, a copy of which has been included with this distribution in  *
 * the LICENSE file.                                                         *
 *****************************************************************************/

package org.apache.batik.refimpl.script;

import org.apache.batik.script.*;
import org.w3c.dom.Document;
import java.util.HashMap;

/**
 * The reference implementation of the <code>InterpreterPool</code> interface.
 * It is able to create <code>Interpreter</code> instances for ECMAScript,
 * Python and Tcl scripting languages if you provide the right jar files in
 * your CLASSPATH (i.e. Rhino, JPython and Jacl jar files).
 * @author <a href="mailto:cjolif@ilog.fr">Christophe Jolif</a>
 * @version $Id$
 */
public class ConcreteInterpreterPool extends InterpreterPool {
        
    private Document document;
    private HashMap factories = new HashMap(3);
    private HashMap interpreters = new HashMap(1);

    private static final String RHINO =
        "org.apache.batik.script.rhino.RhinoInterpreterFactory";

    private static final String JPYTHON =
        "org.apache.batik.script.jpython.JPythonInterpreterFactory";

    private static final String JACL =
        "org.apache.batik.script.jacl.JaclInterpreterFactory";

    /**
     * Builds an instance of <code>ConcreteInterpreterPool</code>.
     */
    public ConcreteInterpreterPool() {
    }

    /**
     * Builds an instance of <code>ConcreteInterpreterPool</code> that
     * will create <code>Interpreter</code> instances for the the given
     * <code>Document</code>.
     */
    public ConcreteInterpreterPool(Document doc) {
        document = doc;
        InterpreterFactory factory = null;
        try {
            factory =
                (InterpreterFactory)Class.forName(RHINO).newInstance();
            putInterpreterFactory("text/ecmascript",
                                  factory);
        } catch (Throwable t1) {
            // may append if the class is not in the CLASSPATH
        }
        try {
            factory =
                (InterpreterFactory)Class.forName(JPYTHON).newInstance();
            putInterpreterFactory("text/python",
                                  factory);
        } catch (Throwable t2) {
            // may append if the class is not in the CLASSPATH
        }
        try {
            factory =
                (InterpreterFactory)Class.forName(JACL).newInstance();
            putInterpreterFactory("text/tcl",
                                  factory);
        } catch (Throwable t3) {
            // may append if the class is not in the CLASSPATH
        }
    }

    /**
     * Returns a unique instance of an implementation of
     * <code>Interpreter</code> interface that match the given language.
     * It returns <code>null</code> if the interpreter cannot be build (for
     * example the language is not recognized by this
     * <code>InterpreterPool</code>). The variable "document" in the returned
     * interpreter will reference the instance of <code>Document</code>
     * to which the <code>InterpreterPool</code> is linked.
     * @param language a mimeType like string describing the language to use
     * (i.e. "text/ecmascript" for ECMAScript interpreter, "text/tcl" for Tcl
     * interpreter...).
     */
    public Interpreter getInterpreter(String language) {
        Interpreter interpreter = (Interpreter)interpreters.get(language);
        if (interpreter == null) {
            InterpreterFactory factory = (InterpreterFactory)factories.
                get(language);
            if (factory != null)
                try {
                    interpreter = factory.createInterpreter();
                    if (document != null) {
                        interpreter.bindObject("document", document);
                    }
                    interpreters.put(language, interpreter);
                } catch (Throwable t) {
                    // may append if the class is here but
                    // not the scripting engine jar
                }
        }
        return interpreter;
    }

    /**
     * Registers an <code>InterpreterFactory</code> for the given
     * language. This allows you to add other languages to the default
     * ones or to replace the <code>InterpreterFactory</code> used to create
     * an <code>Interpreter</code> instance for a particular language to
     * be able to have your own interpreter.
     * @param language the language for which the factory is registered.
     * @parma factory the <code>InterpreterFactory</code> that will allow to
     * create a interpreter for the language.
     */
    public void putInterpreterFactory(String language,
                                      InterpreterFactory factory) {
        factories.put(language, factory);
    }

    /**
     * Unregisters the <code>InterpreterFactory</code> of the given
     * language.
     * @param language the language for which the factory should
     * be unregistered.
     */
    public void removeInterpreterFactory(String language) {
        factories.remove(language);
    }
}