digestingplugin.java

jakarta-struts-1.2.4-src

            }

            if (log.isDebugEnabled()) {
                // TODO Internationalize msg
                log.debug("Configuring custom Digester Ruleset of type " + ruleSet);
            }

            try {
                RuleSet instance =
                    (RuleSet) RequestUtils.applicationInstance(ruleSet);

                digester.addRuleSet(instance);

            } catch (Exception e) {
                // TODO Internationalize msg
                log.error("Exception configuring custom Digester RuleSet", e);
                throw new ServletException(e);
            }
        }
    }

    /**
     * <p>Look up a resource path using one of a set of known path resolution mechanisms
     * and return a URL to the resource.</p>
     * @param path a String which is meaningful to one of the known resolution mechanisms.
     * @param source one of the known path resolution mechanisms:
     * <ul>
     * <li>file - the path is a fully-qualified filesystem path.</li>
     * <li>servlet - the path is a servlet-context relative path.</li>
     * <li>classpath - the path is a classpath-relative path.</li>
     * </ul>
     * @return a URL pointing to the given path in the given mechanism.
     * @throws FileNotFoundException
     * @throws MalformedURLException
     */
    protected URL getConfigURL(String path, String source) throws IOException {

        if (SOURCE_CLASSPATH.equals(this.configSource)) {
            return this.getClassPathURL(path);
        }

        if (SOURCE_FILE.equals(this.configSource)) {
            return this.getFileURL(path);
        }

        if (SOURCE_SERVLET.equals(this.configSource)) {
            return this.getServletContextURL(path);
        }

        // TODO Internationalize msg
        throw new IllegalArgumentException(
            "ConfigSource " + source + " is not recognized");
    }

    /**
     * Given a string, return a URL to a classpath resource of that name.
     * @param path a Classpath-relative string identifying a resource.
     * @return a URL identifying the resource on the classpath.
     * TODO Do we need to be smarter about ClassLoaders?
     */
    protected URL getClassPathURL(String path) {
        return getClass().getClassLoader().getResource(path);
    }

    /**
     * Given a string, return a URL to a Servlet Context resource of that name.
     * @param path a Classpath-relative string identifying a resource.
     * @return a URL identifying the resource in the Servlet Context
     * @throws MalformedURLException
     */
    protected URL getServletContextURL(String path) throws IOException {
        return this.servlet.getServletContext().getResource(path);
    }

    /**
     * Given a string, return a URL to a Filesystem resource of that name.
     * @param path a path to a file.
     * @return a URL identifying the resource in the in the file system.
     * @throws MalformedURLException
     * @throws FileNotFoundException
     */
    protected URL getFileURL(String path) throws IOException {
        File file = new File(path);
        return file.toURL();
    }

    /**
     * @param configPath the path to configuration information for this PlugIn.
     * @see #configSource
     */
    public void setConfigPath(String configPath) {
        this.configPath = configPath;
    }

    /**
     * @return the configPath property
     * @see #configSource
     */
    public String getConfigPath() {
        return configPath;
    }

    /**
     * Set the source of the config file.  Should be one of the following:
     * <ul>
     * <li>
     *      "classpath" - indicates that the configPath will be resolved by the
     *      ClassLoader.
     * </li>
     * <li>
     *      "file" - indicates that the configPath is a fully-qualified
     *      filesystem path.
     * </li>
     * <li>
     *      "servlet" - indicates that the configPath will be found by the
     *      ServletContext.
     * </li>
     * </ul>
     * @param configSource the source (lookup method) for the config file.
     * @see #configPath
     */
    public void setConfigSource(String configSource) {
        this.configSource = configSource;
    }

    /**
     * @return the string describing which access method should be used to
     * resolve configPath.
     * @see #configPath
     */
    public String getConfigSource() {
        return configSource;
    }

    /**
     * This method is called after the Digester runs to store the generated
     * object somewhere.  This implementation places the given object into the
     * ServletContext under the attribute name as defined in <code>key</code>.
     * @param obj The object to save.
     */
    protected void storeGeneratedObject(Object obj) {
        log.debug("Put [" + obj + "] into application context [key:" + this.key + "]");
        this.servlet.getServletContext().setAttribute(this.getKey(), obj);
    }

    /**
     * @param key The ServletContext attribute name to store the generated
     * object under.
     */
    public void setKey(String key) {
        this.key = key;
    }

    /**
     * @return The ServletContext attribute name the generated object is stored
     * under.
     */
    public String getKey() {
        return key;
    }

    /**
     * <p>A comma-delimited list of one or more classes which implement
     * <code>org.apache.commons.digester.RuleSet</code>. (Optional)</p>
     */
    public void setRulesets(String ruleSets) {
        this.rulesets = ruleSets;
    }

    /**
     * @return The configured list of <code>RuleSet</code> classes.
     */
    public String getRulesets() {
        return this.rulesets;
    }

    /**
     * <p>The path to a Digester XML configuration file, relative to the
     * <code>digesterSource</code> property. (Optional)</p>
     * @see #digesterSource
     * @see #getConfigURL(String, String)
     */
    public void setDigesterPath(String digesterPath) {
        this.digesterPath = digesterPath;
    }

    /**
     * @return the configured path to a Digester XML config file, or null.
     * @see #digesterSource
     * @see #getConfigURL(String, String)
     */
    public String getDigesterPath() {
        return digesterPath;
    }

    /**
     * <p>The lookup mechanism to be used to resolve <code>digesterPath</code>
     * (optional).
     * </p>
     * @param digesterSource
     * @see #getConfigURL(String, String)
     */
    public void setDigesterSource(String digesterSource) {
        this.digesterSource = digesterSource;
    }

    /**
     * @return the configured lookup mechanism for resolving
     * <code>digesterPath</code>.
     * @see #getConfigURL(String, String)
     */
    public String getDigesterSource() {
        return this.digesterSource;
    }

    /**
     * <p>If set to <code>true</code>, this PlugIn will be pushed onto
     * the Digester stack before the digester <code>parse</code> method is
     * called.</p>
     * <p>Defaults to <code>false</code></p>
     * @param push
     */
    public void setPush(boolean push) {
        this.push = push;
    }

    /**
     * @return Whether or not this <code>PlugIn</code> instance will be pushed
     * onto the <code>Digester</code> stack before <code>digester.parse()</code>
     * is called.
     */
    public boolean getPush() {
        return this.push;
    }

}