Example usage for org.apache.commons.digester Digester addCallMethod

List of usage examples for org.apache.commons.digester Digester addCallMethod

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.digester.*
  5. Digester
  6. addCallMethod

Introduction

In this page you can find the example usage for org.apache.commons.digester Digester addCallMethod.

Prototype

public void addCallMethod(String pattern, String methodName)

Source Link

Document

Add an "call method" rule for a method which accepts no arguments.

Usage

From source file:com.sun.faces.config.rules.FacesConfigRuleSet.java

private void addListEntriesRules(String prefix, Digester digester) {

    digester.addRule(prefix + "/list-entries", new ListEntriesRule());
    digester.addCallMethod(prefix + "/list-entries/null-value", "addNullValue"); // No arguments
    digester.addCallMethod(prefix + "/list-entries/value", "addValue", 0);
    digester.addCallMethod(prefix + "/list-entries/value-class", "setValueClass", 0);

}

From source file:hudson.scm.CVSChangeLogSet.java

public static CVSChangeLogSet parse(final AbstractBuild<?, ?> build, final java.io.File f)
        throws IOException, SAXException {
    Digester digester = new Digester2();
    ArrayList<CVSChangeLog> r = new ArrayList<CVSChangeLog>();
    digester.push(r);/*from w ww.j a  v a  2 s  .c  o  m*/

    digester.addObjectCreate("*/entry", CVSChangeLog.class);
    digester.addBeanPropertySetter("*/entry/changeDate", "changeDateString");
    digester.addBeanPropertySetter("*/entry/date");
    digester.addBeanPropertySetter("*/entry/time");
    digester.addBeanPropertySetter("*/entry/author", "user");
    digester.addBeanPropertySetter("*/entry/msg");
    digester.addSetNext("*/entry", "add");

    digester.addObjectCreate("*/entry/file", File.class);
    digester.addBeanPropertySetter("*/entry/file/name");
    digester.addBeanPropertySetter("*/entry/file/fullName");
    digester.addBeanPropertySetter("*/entry/file/revision");
    digester.addBeanPropertySetter("*/entry/file/prevrevision");
    digester.addCallMethod("*/entry/file/dead", "setDead");
    digester.addSetNext("*/entry/file", "addFile");

    try {
        digester.parse(f);
    } catch (IOException e) {
        throw new IOException2("Failed to parse " + f, e);
    } catch (SAXException e) {
        throw new IOException2("Failed to parse " + f, e);
    }

    // merge duplicate entries. Ant task somehow seems to report duplicate
    // entries.
    for (int i = r.size() - 1; i >= 0; i--) {
        CVSChangeLog log = r.get(i);
        boolean merged = false;
        if (!log.isComplete()) {
            r.remove(log);
            continue;
        }
        for (int j = 0; j < i; j++) {
            CVSChangeLog c = r.get(j);
            if (c.canBeMergedWith(log)) {
                c.merge(log);
                merged = true;
                break;
            }
        }
        if (merged) {
            r.remove(log);
        }
    }

    return new CVSChangeLogSet(build, r);
}

From source file:com.alibaba.antx.config.descriptor.ConfigDescriptorLoader.java

/** ?descriptordigester */
protected Digester getDigester() {
    Digester digester = loadValidatorPlugins();

    // config// ww w. j  a v  a2  s. c  o m
    digester.addSetProperties("config");

    // config/group
    digester.addObjectCreate("config/group", ConfigGroup.class);
    digester.addSetProperties("config/group");
    digester.addSetNext("config/group", "addGroup");

    // config/group/property
    digester.addObjectCreate("config/group/property", ConfigProperty.class);
    digester.addSetProperties("config/group/property");
    digester.addCallMethod("config/group/property", "afterPropertiesSet");
    digester.addSetNext("config/group/property", "addProperty");

    // config/group/property/validator
    PluginCreateRule pcr = new PluginCreateRule(ConfigValidator.class);

    pcr.setPluginIdAttribute(null, "name");

    digester.addRule("config/group/property/validator", pcr);
    digester.addSetNext("config/group/property/validator", "addValidator");

    // config/script/generate
    digester.addObjectCreate("config/script/generate", ConfigGenerate.class);
    digester.addSetProperties("config/script/generate");
    digester.addSetNext("config/script/generate", "addGenerate");

    digester.clear();

    return digester;
}

From source file:org.eclipse.wb.internal.core.model.description.helpers.FactoryDescriptionHelper.java

/**
 * Adds {@link Rule}'s for factory description parsing.
 *//*from   w w  w .j a v a2  s  . com*/
private static void addRules(Digester digester, EditorState state, final Class<?> declaringClass) {
    // allMethodsAreFactories flag
    {
        String pattern = "factory/allMethodsAreFactories";
        digester.addRule(pattern, new Rule() {
            @Override
            public void body(String namespace, String name, String text) throws Exception {
                Object list = getDigester().pop();
                Boolean allMethodsAreFactories = (Boolean) getDigester().pop();
                if ("true".equalsIgnoreCase(text)) {
                    allMethodsAreFactories = Boolean.TRUE;
                }
                if ("false".equalsIgnoreCase(text)) {
                    allMethodsAreFactories = Boolean.FALSE;
                }
                getDigester().push(allMethodsAreFactories);
                getDigester().push(list);
            }
        });
    }
    // methods
    {
        String pattern = "factory/method";
        digester.addRule(pattern, new Rule() {
            @Override
            public void begin(String namespace, String name, Attributes attributes) throws Exception {
                FactoryMethodDescription factoryMethodDescription = new FactoryMethodDescription(
                        declaringClass);
                Boolean allMethodsAreFactories = (Boolean) getDigester().peek(1);
                factoryMethodDescription.setFactory(
                        allMethodsAreFactories != null ? allMethodsAreFactories.booleanValue() : true);
                digester.push(factoryMethodDescription);
            }

            @Override
            public void end(String namespace, String name) throws Exception {
                digester.pop();
            }
        });
        digester.addSetProperties(pattern);
        digester.addSetNext(pattern, "add");
        digester.addCallMethod(pattern, "postProcess");
        ComponentDescriptionHelper.addParametersRules(digester, pattern + "/parameter", state);
    }
    // invocation
    {
        String pattern = "factory/method/invocation";
        digester.addRule(pattern, new ObjectCreateRule(CreationInvocationDescription.class));
        digester.addRule(pattern, new SetListedPropertiesRule(new String[] { "signature" }));
        // arguments
        digester.addCallMethod(pattern, "setArguments", 1);
        digester.addCallParam(pattern, 0);
        // add
        digester.addSetNext(pattern, "addInvocation");
    }
    // name text
    {
        String pattern = "factory/method/name";
        digester.addCallMethod(pattern, "setPresentationName", 1);
        digester.addCallParam(pattern, 0);
    }
    // untyped parameters
    {
        String pattern = "factory/method/parameters/parameter";
        digester.addCallMethod(pattern, "addParameter", 2);
        digester.addCallParam(pattern, 0, "name");
        digester.addCallParam(pattern, 1);
    }
}

From source file:org.opencms.configuration.CmsImportExportConfiguration.java

/**
 * @see org.opencms.configuration.I_CmsXmlConfiguration#addXmlDigesterRules(org.apache.commons.digester.Digester)
 *//*ww w . jav  a 2 s  . c  om*/
public void addXmlDigesterRules(Digester digester) {

    // add finish rule
    digester.addCallMethod("*/" + N_IMPORTEXPORT, "initializeFinished");

    // creation of the import/export manager        
    digester.addObjectCreate("*/" + N_IMPORTEXPORT, CmsImportExportManager.class);
    // import/export manager finished
    digester.addSetNext("*/" + N_IMPORTEXPORT, "setImportExportManager");

    // add rules for import/export handlers
    digester.addObjectCreate("*/" + N_IMPORTEXPORT + "/" + N_IMPORTEXPORTHANDLERS + "/" + N_IMPORTEXPORTHANDLER,
            A_CLASS, CmsConfigurationException.class);
    digester.addSetNext("*/" + N_IMPORTEXPORT + "/" + N_IMPORTEXPORTHANDLERS + "/" + N_IMPORTEXPORTHANDLER,
            "addImportExportHandler");

    // overwrite rule
    digester.addCallMethod("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_OVERWRITE,
            "setOverwriteCollidingResources", 0);

    // convert rule
    digester.addCallMethod("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_CONVERT, "setConvertToXmlPage", 0);

    // old webapp rule
    digester.addCallMethod("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_OLDWEBAPPURL, "setOldWebAppUrl", 0);

    // add rules for the import versions
    digester.addObjectCreate(
            "*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_IMPORTVERSIONS + "/" + N_IMPORTVERSION, A_CLASS,
            CmsConfigurationException.class);
    digester.addSetNext("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_IMPORTVERSIONS + "/" + N_IMPORTVERSION,
            "addImportVersionClass");

    // add rules for the import immutables
    digester.addCallMethod("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_IMMUTABLES + "/" + N_RESOURCE,
            "addImmutableResource", 1);
    digester.addCallParam("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_IMMUTABLES + "/" + N_RESOURCE, 0,
            A_URI);

    // add rules for the import principal translations
    digester.addCallMethod("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_PRINCIPALTRANSLATIONS + "/"
            + N_PRINCIPALTRANSLATION, "addImportPrincipalTranslation", 3);
    digester.addCallParam("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_PRINCIPALTRANSLATIONS + "/"
            + N_PRINCIPALTRANSLATION, 0, A_TYPE);
    digester.addCallParam("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_PRINCIPALTRANSLATIONS + "/"
            + N_PRINCIPALTRANSLATION, 1, A_FROM);
    digester.addCallParam("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_PRINCIPALTRANSLATIONS + "/"
            + N_PRINCIPALTRANSLATION, 2, A_TO);

    // add rules for the ignored properties
    digester.addCallMethod(
            "*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_IGNOREDPROPERTIES + "/" + N_PROPERTY,
            "addIgnoredProperty", 1);
    digester.addCallParam("*/" + N_IMPORTEXPORT + "/" + N_IMPORT + "/" + N_IGNOREDPROPERTIES + "/" + N_PROPERTY,
            0, A_NAME);

    // creation of the static export manager        
    digester.addObjectCreate("*/" + N_STATICEXPORT, CmsStaticExportManager.class);
    // static export manager finished
    digester.addSetNext("*/" + N_STATICEXPORT, "setStaticExportManager");
    // export enabled role
    digester.addCallMethod("*/" + N_STATICEXPORT, "setExportEnabled", 1);
    digester.addCallParam("*/" + N_STATICEXPORT, 0, A_ENABLED);
    // export handler rule
    digester.addCallMethod("*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_HANDLER, "setHandler", 0);
    // link substitution handler rule
    digester.addCallMethod("*/" + N_STATICEXPORT + "/" + N_LINKSUBSTITUTION_HANDLER,
            "setLinkSubstitutionHandler", 0);
    // exportpath rule
    digester.addCallMethod("*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_EXPORTPATH, "setExportPath", 0);
    // exportworkpath rule
    digester.addCallMethod("*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_EXPORTWORKPATH, "setExportWorkPath", 0);
    // exportbackups rule
    digester.addCallMethod("*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_EXPORTBACKUPS, "setExportBackups", 0);
    // default property rule
    digester.addCallMethod("*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_DEFAULT, "setDefault", 0);
    // export suffix rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_DEFAULTSUFFIXES + "/" + N_STATICEXPORT_SUFFIX,
            "setExportSuffix", 1);
    digester.addCallParam(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_DEFAULTSUFFIXES + "/" + N_STATICEXPORT_SUFFIX, 0,
            A_KEY);
    // header rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_EXPORTHEADERS + "/" + N_STATICEXPORT_HEADER,
            "setExportHeader", 0);
    // accept-language rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_REQUESTHEADERS + "/" + N_STATICEXPORT_ACCEPTLANGUAGE,
            "setAcceptLanguageHeader", 0);
    // accept-charset rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_REQUESTHEADERS + "/" + N_STATICEXPORT_ACCEPTCHARSET,
            "setAcceptCharsetHeader", 0);
    // accept-charset rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_REQUESTHEADERS + "/" + N_STATICEXPORT_REMOTEADDR,
            "setRemoteAddr", 0);
    // rfs-prefix rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/" + N_STATICEXPORT_RFS_PREFIX,
            "setRfsPrefix", 0);
    // vfs-prefix rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/" + N_STATICEXPORT_VFS_PREFIX,
            "setVfsPrefix", 0);
    // relative links rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/" + N_STATICEXPORT_RELATIVELINKS,
            "setRelativeLinks", 0);
    // exporturl rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/" + N_STATICEXPORT_EXPORTURL,
            "setExportUrl", 0);
    // plain export optimization rule
    digester.addCallMethod("*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/"
            + N_STATICEXPORT_PLAINOPTIMIZATION, "setPlainExportOptimization", 0);
    // test resource rule
    digester.addCallMethod(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/" + N_STATICEXPORT_TESTRESOURCE,
            "setTestResource", 1);
    digester.addCallParam(
            "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/" + N_STATICEXPORT_TESTRESOURCE, 0,
            A_URI);
    // resources to export rule
    digester.addCallMethod("*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/"
            + N_STATICEXPORT_RESOURCESTORENDER + "/" + N_STATICEXPORT_REGEX, "setExportFolderPattern", 0);

    // export-rules configuration
    String exportRulePath = "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/"
            + N_STATICEXPORT_RESOURCESTORENDER + "/" + N_STATICEXPORT_EXPORTRULES + "/"
            + N_STATICEXPORT_EXPORTRULE;
    digester.addCallMethod(exportRulePath, "addExportRule", 2);
    digester.addCallParam(exportRulePath + "/" + N_STATICEXPORT_NAME, 0);
    digester.addCallParam(exportRulePath + "/" + N_STATICEXPORT_DESCRIPTION, 1);
    digester.addCallMethod(exportRulePath + "/" + N_STATICEXPORT_MODIFIED + "/" + N_STATICEXPORT_REGEX,
            "addExportRuleRegex", 1);
    digester.addCallParam(exportRulePath + "/" + N_STATICEXPORT_MODIFIED + "/" + N_STATICEXPORT_REGEX, 0);
    digester.addCallMethod(exportRulePath + "/" + N_STATICEXPORT_EXPORT + "/" + N_STATICEXPORT_URI,
            "addExportRuleUri", 1);
    digester.addCallParam(exportRulePath + "/" + N_STATICEXPORT_EXPORT + "/" + N_STATICEXPORT_URI, 0);

    // rfs-rules configuration
    String rfsRulePath = "*/" + N_STATICEXPORT + "/" + N_STATICEXPORT_RENDERSETTINGS + "/"
            + N_STATICEXPORT_RFS_RULES + "/" + N_STATICEXPORT_RFS_RULE;
    digester.addCallMethod(rfsRulePath, "addRfsRule", 8);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_NAME, 0);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_DESCRIPTION, 1);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_SOURCE, 2);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_RFS_PREFIX, 3);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_EXPORTPATH, 4);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_EXPORTWORKPATH, 5);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_EXPORTBACKUPS, 6);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_RELATIVELINKS, 7);
    // rfs-rule related system resources
    digester.addCallMethod(rfsRulePath + "/" + N_STATICEXPORT_RELATED_SYSTEM_RES + "/" + N_STATICEXPORT_REGEX,
            "addRfsRuleSystemRes", 1);
    digester.addCallParam(rfsRulePath + "/" + N_STATICEXPORT_RELATED_SYSTEM_RES + "/" + N_STATICEXPORT_REGEX,
            0);

    // add rules for the user data export
    digester.addObjectCreate("*/" + N_USERCSVEXPORT, CmsUserExportSettings.class);
    digester.addCallMethod("*/" + N_USERCSVEXPORT + "/" + N_SEPARATOR, "setSeparator", 0);
    digester.addCallMethod("*/" + N_USERCSVEXPORT + "/" + N_COLUMNS + "/" + N_COLUMN, "addColumn", 0);
    digester.addSetNext("*/" + N_USERCSVEXPORT, "setUserExportSettings");

    // creation of the static repository manager        
    digester.addObjectCreate("*/" + N_REPOSITORIES, CmsRepositoryManager.class);
    digester.addCallMethod("*/" + N_REPOSITORIES, I_CmsConfigurationParameterHandler.INIT_CONFIGURATION_METHOD);
    digester.addSetNext("*/" + N_REPOSITORIES, "setRepositoryManager");

    // repository
    digester.addObjectCreate("*/" + N_REPOSITORIES + "/" + N_REPOSITORY, A_CLASS,
            CmsConfigurationException.class);

    // repository name
    digester.addCallMethod("*/" + N_REPOSITORIES + "/" + N_REPOSITORY, "setName", 1);
    digester.addCallParam("*/" + N_REPOSITORIES + "/" + N_REPOSITORY, 0, A_NAME);

    // repository params
    digester.addCallMethod("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_PARAMS + "/" + N_PARAM,
            I_CmsConfigurationParameterHandler.ADD_PARAMETER_METHOD, 2);
    digester.addCallParam("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_PARAMS + "/" + N_PARAM, 0,
            I_CmsXmlConfiguration.A_NAME);
    digester.addCallParam("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_PARAMS + "/" + N_PARAM, 1);

    // repository filter
    digester.addObjectCreate("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_FILTER,
            CmsRepositoryFilter.class);

    // repository filter type
    digester.addCallMethod("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_FILTER, "setType", 1);
    digester.addCallParam("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_FILTER, 0, A_TYPE);

    // repository filter rules
    digester.addCallMethod("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_FILTER + "/" + N_REGEX,
            "addFilterRule", 1);
    digester.addCallParam("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_FILTER + "/" + N_REGEX, 0);

    digester.addSetNext("*/" + N_REPOSITORIES + "/" + N_REPOSITORY + "/" + N_FILTER, "setFilter");

    digester.addSetNext("*/" + N_REPOSITORIES + "/" + N_REPOSITORY, "addRepositoryClass");

    // create at least a repository manager though no repositories are configured
    if (m_repositoryManager == null) {
        m_repositoryManager = new CmsRepositoryManager(false);
    }
    // creation of the extended HTML importer       
    digester.addObjectCreate("*/" + N_EXTHTMLIMPORT, CmsExtendedHtmlImportDefault.class);
    // extended HTML importer  finished
    digester.addSetNext("*/" + N_EXTHTMLIMPORT, "setExtendedHtmlImportManager");
    digester.addCallMethod("*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_DESTINATION, "setDestinationDir", 0);
    digester.addCallMethod("*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_INPUT, "setInputDir", 0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_GALLERIES + "/" + N_EXTHTMLIMPORT_DOWNLOAD,
            "setDownloadGallery", 0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_GALLERIES + "/" + N_EXTHTMLIMPORT_IMAGE,
            "setImageGallery", 0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_GALLERIES + "/" + N_EXTHTMLIMPORT_EXTERNALLINK,
            "setLinkGallery", 0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_SETTINGS + "/" + N_EXTHTMLIMPORT_TEMPLATE,
            "setTemplate", 0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_SETTINGS + "/" + N_EXTHTMLIMPORT_ELEMENT,
            "setElement", 0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_SETTINGS + "/" + N_EXTHTMLIMPORT_LOCALE, "setLocale",
            0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_SETTINGS + "/" + N_EXTHTMLIMPORT_ENCODING,
            "setEncoding", 0);
    digester.addCallMethod("*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_SETTINGS + "/"
            + N_EXTHTMLIMPORT_PATTERN + "/" + N_EXTHTMLIMPORT_PATTERN_START, "setStartPattern", 0);
    digester.addCallMethod("*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_SETTINGS + "/"
            + N_EXTHTMLIMPORT_PATTERN + "/" + N_EXTHTMLIMPORT_PATTERN_END, "setEndPattern", 0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_SETTINGS + "/" + N_EXTHTMLIMPORT_OVERWRITE,
            "setOverwrite", 0);
    digester.addCallMethod(
            "*/" + N_EXTHTMLIMPORT + "/" + N_EXTHTMLIMPORT_SETTINGS + "/" + N_EXTHTMLIMPORT_KEEPBROKENLINKS,
            "setKeepBrokenLinks", 0);
}

From source file:org.opencms.configuration.CmsModuleConfiguration.java

/**
 * @see org.opencms.configuration.I_CmsXmlConfiguration#addXmlDigesterRules(org.apache.commons.digester.Digester)
 *//*from   ww w .ja  va  2  s  .  c  om*/
public void addXmlDigesterRules(Digester digester) {

    // add finish rule
    digester.addCallMethod("*/" + N_MODULES, "initializeFinished");

    // add the module rules for the module digester
    CmsModuleXmlHandler.addXmlDigesterRules(digester);
}

From source file:org.opencms.configuration.CmsSearchConfiguration.java

/**
 * @see org.opencms.configuration.I_CmsXmlConfiguration#addXmlDigesterRules(org.apache.commons.digester.Digester)
 *///from   w  w w  .j  a  va2 s  . com
public void addXmlDigesterRules(Digester digester) {

    String xPath = null;

    // add finish rule
    digester.addCallMethod(XPATH_SEARCH, "initializeFinished");

    // creation of the search manager        
    digester.addObjectCreate(XPATH_SEARCH, A_CLASS, CmsSearchManager.class);

    // search manager finished
    digester.addSetNext(XPATH_SEARCH, "setSearchManager");

    // directory rule
    digester.addCallMethod(XPATH_SEARCH + "/" + N_DIRECTORY, "setDirectory", 0);

    // timeout rule
    digester.addCallMethod(XPATH_SEARCH + "/" + N_TIMEOUT, "setTimeout", 0);

    // offline update rule
    digester.addCallMethod(XPATH_SEARCH + "/" + N_OFFLINE_UPDATE_FREQUENCY, "setOfflineUpdateFrequency", 0);

    // forceunlock rule
    digester.addCallMethod(XPATH_SEARCH + "/" + N_FORCEUNLOCK, "setForceunlock", 0);

    // rule for the max. char. lenght of the search result excerpt
    digester.addCallMethod(XPATH_SEARCH + "/" + N_EXCERPT, "setMaxExcerptLength", 0);

    // rule for the max. age of entries in the extraction cache
    digester.addCallMethod(XPATH_SEARCH + "/" + N_EXTRACTION_CACHE_MAX_AGE, "setExtractionCacheMaxAge", 0);

    // rule for max. number of modifications before commit
    digester.addCallMethod(XPATH_SEARCH + "/" + N_MAX_MODIFICATIONS_BEFORE_COMMIT,
            "setMaxModificationsBeforeCommit", 0);

    // rule for the highlighter to highlight the search terms in the excerpt of the search result
    digester.addCallMethod(XPATH_SEARCH + "/" + N_HIGHLIGHTER, "setHighlighter", 0);

    // document type rule
    xPath = XPATH_SEARCH + "/" + N_DOCUMENTTYPES + "/" + N_DOCUMENTTYPE;
    digester.addObjectCreate(xPath, CmsSearchDocumentType.class);
    digester.addCallMethod(xPath + "/" + N_NAME, "setName", 0);
    digester.addCallMethod(xPath + "/" + N_CLASS, "setClassName", 0);
    digester.addCallMethod(xPath + "/" + N_MIMETYPES + "/" + N_MIMETYPE, "addMimeType", 0);
    digester.addCallMethod(xPath + "/" + N_RESOURCETYPES + "/" + N_RESOURCETYPE, "addResourceType", 0);
    digester.addSetNext(xPath, "addDocumentTypeConfig");

    // analyzer rule
    xPath = XPATH_SEARCH + "/" + N_ANALYZERS + "/" + N_ANALYZER;
    digester.addObjectCreate(xPath, CmsSearchAnalyzer.class);
    digester.addCallMethod(xPath + "/" + N_CLASS, "setClassName", 0);
    digester.addCallMethod(xPath + "/" + N_STEMMER, "setStemmerAlgorithm", 0);
    digester.addCallMethod(xPath + "/" + N_LOCALE, "setLocaleString", 0);
    digester.addSetNext(xPath, "addAnalyzer");

    // search index rule
    xPath = XPATH_SEARCH + "/" + N_INDEXES + "/" + N_INDEX;
    digester.addObjectCreate(xPath, A_CLASS, CmsSearchIndex.class);
    digester.addCallMethod(xPath + "/" + N_NAME, "setName", 0);
    digester.addCallMethod(xPath + "/" + N_REBUILD, "setRebuildMode", 0);
    digester.addCallMethod(xPath + "/" + N_PROJECT, "setProjectName", 0);
    digester.addCallMethod(xPath + "/" + N_LOCALE, "setLocaleString", 0);
    digester.addCallMethod(xPath + "/" + N_CONFIGURATION, "setFieldConfigurationName", 0);
    digester.addCallMethod(xPath + "/" + N_SOURCES + "/" + N_SOURCE, "addSourceName", 0);
    digester.addSetNext(xPath, "addSearchIndex");

    // search index source rule
    xPath = XPATH_SEARCH + "/" + N_INDEXSOURCES + "/" + N_INDEXSOURCE;
    digester.addObjectCreate(xPath, CmsSearchIndexSource.class);
    digester.addCallMethod(xPath + "/" + N_NAME, "setName", 0);
    digester.addCallMethod(xPath + "/" + N_INDEXER, "setIndexerClassName", 1);
    digester.addCallParam(xPath + "/" + N_INDEXER, 0, N_CLASS);
    digester.addCallMethod(xPath + "/" + N_RESOURCES + "/" + N_RESOURCE, "addResourceName", 0);
    digester.addCallMethod(xPath + "/" + N_DOCUMENTTYPES_INDEXED + "/" + N_NAME, "addDocumentType", 0);
    digester.addSetNext(xPath, "addSearchIndexSource");

    // field configuration rules
    xPath = XPATH_SEARCH + "/" + N_FIELDCONFIGURATIONS + "/" + N_FIELDCONFIGURATION;
    digester.addObjectCreate(xPath, A_CLASS, CmsSearchFieldConfiguration.class);
    digester.addCallMethod(xPath + "/" + N_NAME, "setName", 0);
    digester.addCallMethod(xPath + "/" + N_DESCRIPTION, "setDescription", 0);
    digester.addSetNext(xPath, "addFieldConfiguration");

    xPath = xPath + "/" + N_FIELDS + "/" + N_FIELD;
    digester.addObjectCreate(xPath, CmsSearchField.class);
    digester.addCallMethod(xPath, "setName", 1);
    digester.addCallParam(xPath, 0, I_CmsXmlConfiguration.A_NAME);
    digester.addCallMethod(xPath, "setDisplayNameForConfiguration", 1);
    digester.addCallParam(xPath, 0, A_DISPLAY);
    digester.addCallMethod(xPath, "setStored", 1);
    digester.addCallParam(xPath, 0, A_STORE);
    digester.addCallMethod(xPath, "setIndexed", 1);
    digester.addCallParam(xPath, 0, A_INDEX);
    digester.addCallMethod(xPath, "setInExcerpt", 1);
    digester.addCallParam(xPath, 0, A_EXCERPT);
    digester.addCallMethod(xPath, "setAnalyzer", 1);
    digester.addCallParam(xPath, 0, A_ANALYZER);
    digester.addCallMethod(xPath, "setBoost", 1);
    digester.addCallParam(xPath, 0, A_BOOST);
    digester.addCallMethod(xPath, "setDefaultValue", 1);
    digester.addCallParam(xPath, 0, A_DEFAULT);
    digester.addSetNext(xPath, "addField");

    xPath = xPath + "/" + N_MAPPING;
    digester.addObjectCreate(xPath, A_CLASS, CmsSearchFieldMapping.class);
    digester.addCallMethod(xPath, "setDefaultValue", 1);
    digester.addCallParam(xPath, 0, A_DEFAULT);
    digester.addCallMethod(xPath, "setType", 1);
    digester.addCallParam(xPath, 0, A_TYPE);
    digester.addCallMethod(xPath, "setParam", 0);
    digester.addSetNext(xPath, "addMapping");

    // generic <param> parameter rules
    digester.addCallMethod("*/" + I_CmsXmlConfiguration.N_PARAM,
            I_CmsConfigurationParameterHandler.ADD_PARAMETER_METHOD, 2);
    digester.addCallParam("*/" + I_CmsXmlConfiguration.N_PARAM, 0, I_CmsXmlConfiguration.A_NAME);
    digester.addCallParam("*/" + I_CmsXmlConfiguration.N_PARAM, 1);
}

From source file:org.opencms.configuration.CmsSystemConfiguration.java

/**
 * @see org.opencms.configuration.I_CmsXmlConfiguration#addXmlDigesterRules(org.apache.commons.digester.Digester)
 *///from   w ww  .j  a va2  s .  com
public void addXmlDigesterRules(Digester digester) {

    // add finish rule
    digester.addCallMethod("*/" + N_SYSTEM, "initializeFinished");

    // add rule for internationalization
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_I18N, CmsLocaleManager.class);
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_I18N, "setLocaleManager");

    // add locale handler creation rule
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_I18N + "/" + N_LOCALEHANDLER, A_CLASS,
            CmsConfigurationException.class);
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_I18N + "/" + N_LOCALEHANDLER, "setLocaleHandler");

    // add locale rules
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_I18N + "/" + N_LOCALESCONFIGURED + "/" + N_LOCALE,
            "addAvailableLocale", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_I18N + "/" + N_LOCALESDEFAULT + "/" + N_LOCALE,
            "addDefaultLocale", 0);
    // add time zone rule
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_I18N + "/" + N_TIMEZONE, "setTimeZone", 0);

    // add version history rules
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_VERSIONHISTORY, "setHistorySettings", 3);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_VERSIONHISTORY, 0, A_ENABLED);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_VERSIONHISTORY, 1, A_COUNT);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_VERSIONHISTORY, 2, A_DELETED);

    // add mail configuration rule
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_MAIL, CmsMailSettings.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_MAIL + "/" + N_MAILFROM, "setMailFromDefault", 0);
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_MAIL, "setMailSettings");

    // add mail host configuration rule
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_MAIL + "/" + N_MAILHOST, "addMailHost", 6);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MAIL + "/" + N_MAILHOST, 0, A_NAME);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MAIL + "/" + N_MAILHOST, 1, A_PORT);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MAIL + "/" + N_MAILHOST, 2, A_ORDER);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MAIL + "/" + N_MAILHOST, 3, A_PROTOCOL);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MAIL + "/" + N_MAILHOST, 4, A_USER);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MAIL + "/" + N_MAILHOST, 5, A_PASSWORD);

    // add scheduler creation rule
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SCHEDULER, "addScheduleManager");

    // add scheduler job creation rule
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB, CmsScheduledJobInfo.class);
    digester.addBeanPropertySetter("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_NAME, "jobName");
    digester.addBeanPropertySetter("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CLASS,
            "className");
    digester.addBeanPropertySetter("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CRONEXPRESSION,
            "cronExpression");
    digester.addBeanPropertySetter("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_REUSEINSTANCE,
            "reuseInstance");
    digester.addBeanPropertySetter("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_ACTIVE,
            "active");
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB, "addJobFromConfiguration");

    // add job context creation rule
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT,
            CmsContextInfo.class);
    digester.addBeanPropertySetter(
            "*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT + "/" + N_USERNAME, "userName");
    digester.addBeanPropertySetter(
            "*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT + "/" + N_PROJECT,
            "projectName");
    digester.addBeanPropertySetter(
            "*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT + "/" + N_SITEROOT, "siteRoot");
    digester.addBeanPropertySetter(
            "*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT + "/" + N_REQUESTEDURI,
            "requestedUri");
    digester.addBeanPropertySetter(
            "*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT + "/" + N_LOCALE, "localeName");
    digester.addBeanPropertySetter(
            "*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT + "/" + N_ENCODING);
    digester.addBeanPropertySetter(
            "*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT + "/" + N_REMOTEADDR,
            "remoteAddr");
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_SCHEDULER + "/" + N_JOB + "/" + N_CONTEXT, "setContextInfo");

    // add generic parameter rules (used for jobs, password handler)
    digester.addCallMethod("*/" + I_CmsXmlConfiguration.N_PARAM,
            I_CmsConfigurationParameterHandler.ADD_PARAMETER_METHOD, 2);
    digester.addCallParam("*/" + I_CmsXmlConfiguration.N_PARAM, 0, I_CmsXmlConfiguration.A_NAME);
    digester.addCallParam("*/" + I_CmsXmlConfiguration.N_PARAM, 1);

    // add event classes
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_EVENTS + "/" + N_EVENTMANAGER, "addEventManager", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_EVENTS + "/" + N_EVENTMANAGER, 0, A_CLASS);

    // add resource init classes
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESOURCEINIT + "/" + N_RESOURCEINITHANDLER,
            "addResourceInitHandler", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_RESOURCEINIT + "/" + N_RESOURCEINITHANDLER, 0, A_CLASS);

    // add request handler classes
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_REQUESTHANDLERS + "/" + N_REQUESTHANDLER,
            "addRequestHandler", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_REQUESTHANDLERS + "/" + N_REQUESTHANDLER, 0, A_CLASS);

    // add password handler creation rule
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_PASSWORDHANDLER, A_CLASS,
            CmsConfigurationException.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_PASSWORDHANDLER,
            I_CmsConfigurationParameterHandler.INIT_CONFIGURATION_METHOD);
    digester.addBeanPropertySetter("*/" + N_SYSTEM + "/" + N_PASSWORDHANDLER + "/" + N_PASSWORDENCODING,
            "inputEncoding");
    digester.addBeanPropertySetter("*/" + N_SYSTEM + "/" + N_PASSWORDHANDLER + "/" + N_DIGESTTYPE,
            "digestType");
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_PASSWORDHANDLER, "setPasswordHandler");

    // add validation handler creation rules
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_VALIDATIONHANDLER, "setValidationHandler", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_VALIDATIONHANDLER, 0, A_CLASS);

    // add login manager creation rules
    digester.addCallMethod("*/" + N_LOGINMANAGER, "setLoginManager", 3);
    digester.addCallParam("*/" + N_LOGINMANAGER + "/" + N_DISABLEMINUTES, 0);
    digester.addCallParam("*/" + N_LOGINMANAGER + "/" + N_MAXBADATTEMPTS, 1);
    digester.addCallParam("*/" + N_LOGINMANAGER + "/" + N_ENABLESCURITY, 2);

    // add login message creation rules
    digester.addObjectCreate("*/" + N_LOGINMESSAGE, CmsLoginMessage.class);
    digester.addBeanPropertySetter("*/" + N_LOGINMESSAGE + "/" + N_ENABLED);
    digester.addBeanPropertySetter("*/" + N_LOGINMESSAGE + "/" + N_MESSAGE);
    digester.addBeanPropertySetter("*/" + N_LOGINMESSAGE + "/" + N_LOGINFORBIDDEN);
    digester.addBeanPropertySetter("*/" + N_LOGINMESSAGE + "/" + N_TIMESTART);
    digester.addBeanPropertySetter("*/" + N_LOGINMESSAGE + "/" + N_TIMEEND);
    digester.addSetNext("*/" + N_LOGINMESSAGE, "setLoginMessage");

    // add site configuration rule        
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_SITES, CmsSiteManagerImpl.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_WORKPLACE_SERVER, "setWorkplaceServer", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_DEFAULT_URI, "setDefaultUri", 0);
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_SITES, "setSiteManager");

    // add site configuration rule
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE, "addSite", 5);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE, 0, A_SERVER);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE, 1, A_URI);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE + "/" + N_SECURE, 2, A_SERVER);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE + "/" + N_SECURE, 3, A_EXCLUSIVE);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE + "/" + N_SECURE, 4, A_ERROR);

    // add an alias to the currently configured site
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE + "/" + N_ALIAS,
            "addAliasToConfigSite", 2);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE + "/" + N_ALIAS, 0, A_SERVER);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SITE + "/" + N_ALIAS, 1, A_OFFSET);

    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SITES + "/" + N_SHARED_FOLDER, "setSharedFolder", 0);

    // add compatibility parameter rules 
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RUNTIMEPROPERTIES + "/" + N_PARAM,
            I_CmsConfigurationParameterHandler.ADD_PARAMETER_METHOD, 2);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_RUNTIMEPROPERTIES + "/" + N_PARAM, 0,
            I_CmsXmlConfiguration.A_NAME);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_RUNTIMEPROPERTIES + "/" + N_PARAM, 1);

    // add runtime classes configuration rules
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RUNTIMECLASSES + "/" + N_RUNTIMEINFO,
            "setRuntimeInfoFactory", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_RUNTIMECLASSES + "/" + N_RUNTIMEINFO, 0, A_CLASS);

    // add default users rule
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS, "setCmsDefaultUsers", 8);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS + "/" + N_USER_ADMIN, 0);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS + "/" + N_USER_GUEST, 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS + "/" + N_USER_EXPORT, 2);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS + "/" + N_USER_DELETEDRESOURCE, 3);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS + "/" + N_GROUP_ADMINISTRATORS, 4);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS + "/" + N_GROUP_PROJECTMANAGERS, 5);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS + "/" + N_GROUP_USERS, 6);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULTUSERS + "/" + N_GROUP_GUESTS, 7);

    // add defaultContentEncoding rule
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_DEFAULT_CONTENT_ENCODING, "setDefaultContentEncoding", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_DEFAULT_CONTENT_ENCODING, 0);

    // add memorymonitor configuration rule        
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR, CmsMemoryMonitorConfiguration.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR, "initialize", 5);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR, 0, A_CLASS);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR + "/" + N_MAXUSAGE_PERCENT, 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR + "/" + N_LOG_INTERVAL, 2);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR + "/" + N_EMAIL_INTERVAL, 3);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR + "/" + N_WARNING_INTERVAL, 4);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR + "/" + N_EMAIL_SENDER, "setEmailSender", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR + "/" + N_EMAIL_RECEIVER + "/" + N_RECEIVER,
            "addEmailReceiver", 0);

    // set the MemoryMonitorConfiguration initialized once before
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_MEMORYMONITOR, "setCmsMemoryMonitorConfiguration");

    // add flexcache configuration rule        
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_FLEXCACHE, CmsFlexCacheConfiguration.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_FLEXCACHE, "initialize", 6);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_FLEXCACHE + "/" + N_CACHE_ENABLED, 0);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_FLEXCACHE + "/" + N_CACHE_OFFLINE, 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_FLEXCACHE + "/" + N_MAXCACHEBYTES, 2);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_FLEXCACHE + "/" + N_AVGCACHEBYTES, 3);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_FLEXCACHE + "/" + N_MAXENTRYBYTES, 4);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_FLEXCACHE + "/" + N_MAXKEYS, 5);
    // add flexcache device selector
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_FLEXCACHE + "/" + N_DEVICESELECTOR,
            "setDeviceSelectorConfiguration", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_FLEXCACHE + "/" + N_DEVICESELECTOR, 0, A_CLASS);

    // set the FlexCacheConfiguration initialized once before
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_FLEXCACHE, "setCmsFlexCacheConfiguration");

    // add http basic authentication rules
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_HTTP_AUTHENTICATION,
            CmsHttpAuthenticationSettings.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_HTTP_AUTHENTICATION + "/" + N_BROWSER_BASED,
            "setUseBrowserBasedHttpAuthentication", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_HTTP_AUTHENTICATION + "/" + N_FORM_BASED,
            "setFormBasedHttpAuthenticationUri", 0);
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_HTTP_AUTHENTICATION, "setHttpAuthenticationSettings");

    // cache rules
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_RESULTCACHE, CmsCacheSettings.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_KEYGENERATOR, "setCacheKeyGenerator",
            0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_USERS, "setUserCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_GROUPS, "setGroupCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_ORGUNITS, "setOrgUnitCacheSize",
            0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_USERGROUPS,
            "setUserGroupsCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_PROJECTS, "setProjectCacheSize",
            0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_PROJECTRESOURCES,
            "setProjectResourcesCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_RESOURCES,
            "setResourceCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_ROLES, "setRolesCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_RESOURCELISTS,
            "setResourcelistCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_PROPERTIES,
            "setPropertyCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_PROPERTYLISTS,
            "setPropertyListsCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_ACLS, "setAclCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_PERMISSIONS,
            "setPermissionCacheSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_CONTAINERPAGE_OFFLINE,
            "setContainerPageOfflineSize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_RESULTCACHE + "/" + N_SIZE_CONTAINERPAGE_ONLINE,
            "setContainerPageOnlineSize", 0);
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_RESULTCACHE, "setCacheSettings");

    // set the notification time
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_CONTENT_NOTIFICATION + "/" + N_NOTIFICATION_TIME,
            "setNotificationTime", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_CONTENT_NOTIFICATION + "/" + N_NOTIFICATION_TIME, 0);

    // set the notification project
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_CONTENT_NOTIFICATION + "/" + N_NOTIFICATION_PROJECT,
            "setNotificationProject", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_CONTENT_NOTIFICATION + "/" + N_NOTIFICATION_PROJECT, 0);

    // add authorization handler creation rules
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_AUTHORIZATIONHANDLER, "setAuthorizationHandler", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_AUTHORIZATIONHANDLER, 0, A_CLASS);

    // add publish manager configuration rule        
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_PUBLISHMANAGER, CmsPublishManager.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_PUBLISHMANAGER + "/" + N_HISTORYSIZE,
            "setPublishHistorySize", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_PUBLISHMANAGER + "/" + N_QUEUEPERSISTANCE,
            "setPublishQueuePersistance", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_PUBLISHMANAGER + "/" + N_QUEUESHUTDOWNTIME,
            "setPublishQueueShutdowntime", 0);
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_PUBLISHMANAGER, "setPublishManager");

    // add rule for session storage provider
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SESSION_STORAGEPROVIDER, "setSessionStorageProvider", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SESSION_STORAGEPROVIDER, 0, A_CLASS);

    // add rule for permission handler
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_PERMISSIONHANDLER, "setPermissionHandler", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_PERMISSIONHANDLER, 0, A_CLASS);

    // add rules for servlet container settings
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SERVLETCONTAINERSETTINGS + "/" + N_PREVENTRESPONSEFLUSH,
            "setPreventResponseFlush", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SERVLETCONTAINERSETTINGS + "/" + N_RELEASETAGSAFTEREND,
            "setReleaseTagsAfterEnd", 0);
    digester.addCallMethod(
            "*/" + N_SYSTEM + "/" + N_SERVLETCONTAINERSETTINGS + "/" + N_REQUESTERRORPAGEATTRIBUTE,
            "setRequestErrorPageAttribute", 0);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SERVLETCONTAINERSETTINGS,
            "setServletContainerSettingsMode", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SERVLETCONTAINERSETTINGS, 0, A_MODE);

    // add rule for ADE cache settings
    String adeCachePath = "*/" + N_SYSTEM + "/" + N_ADE + "/" + N_ADE_CACHE;
    digester.addObjectCreate(adeCachePath, CmsADECacheSettings.class);
    // container page cache
    digester.addCallMethod(adeCachePath + "/" + N_CONTAINERPAGES, "setContainerPageOfflineSize", 1);
    digester.addCallParam(adeCachePath + "/" + N_CONTAINERPAGES, 0, A_OFFLINE);
    digester.addCallMethod(adeCachePath + "/" + N_CONTAINERPAGES, "setContainerPageOnlineSize", 1);
    digester.addCallParam(adeCachePath + "/" + N_CONTAINERPAGES, 0, A_ONLINE);
    // groupcontainer cache
    digester.addCallMethod(adeCachePath + "/" + N_GROUPCONTAINERS, "setGroupContainerOfflineSize", 1);
    digester.addCallParam(adeCachePath + "/" + N_GROUPCONTAINERS, 0, A_OFFLINE);
    digester.addCallMethod(adeCachePath + "/" + N_GROUPCONTAINERS, "setGroupContainerOnlineSize", 1);
    digester.addCallParam(adeCachePath + "/" + N_GROUPCONTAINERS, 0, A_ONLINE);
    // set the settings
    digester.addSetNext(adeCachePath, "setAdeCacheSettings");

    // add rule for subscription manager settings
    digester.addObjectCreate("*/" + N_SYSTEM + "/" + N_SUBSCRIPTIONMANAGER, CmsSubscriptionManager.class);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SUBSCRIPTIONMANAGER, "setEnabled", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SUBSCRIPTIONMANAGER, 0, A_ENABLED);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SUBSCRIPTIONMANAGER, "setPoolName", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SUBSCRIPTIONMANAGER, 0, A_POOLNAME);
    digester.addCallMethod("*/" + N_SYSTEM + "/" + N_SUBSCRIPTIONMANAGER, "setMaxVisitedCount", 1);
    digester.addCallParam("*/" + N_SYSTEM + "/" + N_SUBSCRIPTIONMANAGER, 0, A_MAXVISITED);
    digester.addSetNext("*/" + N_SYSTEM + "/" + N_SUBSCRIPTIONMANAGER, "setSubscriptionManager");
}

From source file:org.opencms.configuration.CmsVfsConfiguration.java

/**
 * @see org.opencms.configuration.I_CmsXmlConfiguration#addXmlDigesterRules(org.apache.commons.digester.Digester)
 *//* ww  w  .  ja v a  2s.  c o m*/
public void addXmlDigesterRules(Digester digester) {

    // add finish rule
    digester.addCallMethod("*/" + N_VFS, "initializeFinished");

    // creation of the resource manager
    digester.addObjectCreate("*/" + N_VFS + "/" + N_RESOURCES, CmsResourceManager.class);
    digester.addCallMethod("*/" + N_VFS + "/" + N_RESOURCES,
            I_CmsConfigurationParameterHandler.INIT_CONFIGURATION_METHOD);
    digester.addSetNext("*/" + N_VFS + "/" + N_RESOURCES, "setResourceManager");

    // add rules for resource loaders
    digester.addObjectCreate("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_RESOURCELOADERS + "/" + N_LOADER,
            A_CLASS, CmsConfigurationException.class);
    digester.addCallMethod("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_RESOURCELOADERS + "/" + N_LOADER,
            I_CmsConfigurationParameterHandler.INIT_CONFIGURATION_METHOD);
    digester.addSetNext("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_RESOURCELOADERS + "/" + N_LOADER,
            "addLoader");

    // add rules for resource types
    addResourceTypeXmlRules(digester);

    // add rules for VFS content collectors
    digester.addCallMethod("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_COLLECTORS + "/" + N_COLLECTOR,
            "addContentCollector", 2);
    digester.addCallParam("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_COLLECTORS + "/" + N_COLLECTOR, 0,
            A_CLASS);
    digester.addCallParam("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_COLLECTORS + "/" + N_COLLECTOR, 1,
            A_ORDER);

    // add the name generator 
    digester.addObjectCreate("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_NAMEGENERATOR,
            CmsDefaultFileNameGenerator.class);
    digester.addSetNext("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_NAMEGENERATOR, "setNameGenerator");

    // add MIME type rules
    digester.addCallMethod("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_MIMETYPES + "/" + N_MIMETYPE,
            "addMimeType", 2);
    digester.addCallParam("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_MIMETYPES + "/" + N_MIMETYPE, 0,
            A_EXTENSION);
    digester.addCallParam("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_MIMETYPES + "/" + N_MIMETYPE, 1, A_TYPE);

    // add relation type rules
    digester.addCallMethod("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_RELATIONTYPES + "/" + N_RELATIONTYPE,
            "addRelationType", 2);
    digester.addCallParam("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_RELATIONTYPES + "/" + N_RELATIONTYPE, 0,
            A_NAME);
    digester.addCallParam("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_RELATIONTYPES + "/" + N_RELATIONTYPE, 1,
            A_TYPE);

    // add html converter rules
    digester.addCallMethod("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_HTML_CONVERTERS + "/" + N_HTML_CONVERTER,
            "addHtmlConverter", 2);
    digester.addCallParam("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_HTML_CONVERTERS + "/" + N_HTML_CONVERTER,
            0, A_NAME);
    digester.addCallParam("*/" + N_VFS + "/" + N_RESOURCES + "/" + N_HTML_CONVERTERS + "/" + N_HTML_CONVERTER,
            1, A_CLASS);

    // generic <param> parameter rules
    digester.addCallMethod("*/" + I_CmsXmlConfiguration.N_PARAM,
            I_CmsConfigurationParameterHandler.ADD_PARAMETER_METHOD, 2);
    digester.addCallParam("*/" + I_CmsXmlConfiguration.N_PARAM, 0, I_CmsXmlConfiguration.A_NAME);
    digester.addCallParam("*/" + I_CmsXmlConfiguration.N_PARAM, 1);

    // add rule for default files
    digester.addCallMethod("*/" + N_VFS + "/" + N_DEFAULTFILES + "/" + N_DEFAULTFILE, "addDefaultFile", 1);
    digester.addCallParam("*/" + N_VFS + "/" + N_DEFAULTFILES + "/" + N_DEFAULTFILE, 0, A_NAME);

    // add rules for file translations
    digester.addCallMethod("*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_FILETRANSLATIONS + "/" + N_TRANSLATION,
            "addFileTranslation", 0);
    digester.addCallMethod("*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_FILETRANSLATIONS,
            "setFileTranslationEnabled", 1);
    digester.addCallParam("*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_FILETRANSLATIONS, 0, A_ENABLED);

    // add rules for file translations
    digester.addCallMethod(
            "*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_FOLDERTRANSLATIONS + "/" + N_TRANSLATION,
            "addFolderTranslation", 0);
    digester.addCallMethod("*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_FOLDERTRANSLATIONS,
            "setFolderTranslationEnabled", 1);
    digester.addCallParam("*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_FOLDERTRANSLATIONS, 0, A_ENABLED);

    // add rules for file translations
    digester.addCallMethod("*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_XSDTRANSLATIONS + "/" + N_TRANSLATION,
            "addXsdTranslation", 0);
    digester.addCallMethod("*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_XSDTRANSLATIONS,
            "setXsdTranslationEnabled", 1);
    digester.addCallParam("*/" + N_VFS + "/" + N_TRANSLATIONS + "/" + N_XSDTRANSLATIONS, 0, A_ENABLED);

    // XML content type manager creation rules
    digester.addObjectCreate("*/" + N_VFS + "/" + N_XMLCONTENT, CmsXmlContentTypeManager.class);
    digester.addSetNext("*/" + N_VFS + "/" + N_XMLCONTENT, "setXmlContentTypeManager");

    // XML content widgets add rules
    digester.addCallMethod("*/" + N_VFS + "/" + N_XMLCONTENT + "/" + N_WIDGETS + "/" + N_WIDGET, "addWidget",
            3);
    digester.addCallParam("*/" + N_VFS + "/" + N_XMLCONTENT + "/" + N_WIDGETS + "/" + N_WIDGET, 0, A_CLASS);
    digester.addCallParam("*/" + N_VFS + "/" + N_XMLCONTENT + "/" + N_WIDGETS + "/" + N_WIDGET, 1, A_ALIAS);
    digester.addCallParam("*/" + N_VFS + "/" + N_XMLCONTENT + "/" + N_WIDGETS + "/" + N_WIDGET, 2,
            A_CONFIGURATION);

    // XML content schema type add rules
    digester.addCallMethod("*/" + N_VFS + "/" + N_XMLCONTENT + "/" + N_SCHEMATYPES + "/" + N_SCHEMATYPE,
            "addSchemaType", 2);
    digester.addCallParam("*/" + N_VFS + "/" + N_XMLCONTENT + "/" + N_SCHEMATYPES + "/" + N_SCHEMATYPE, 0,
            A_CLASS);
    digester.addCallParam("*/" + N_VFS + "/" + N_XMLCONTENT + "/" + N_SCHEMATYPES + "/" + N_SCHEMATYPE, 1,
            A_DEFAULTWIDGET);
}

From source file:org.opencms.configuration.CmsWorkplaceConfiguration.java

/**
 * @see org.opencms.configuration.I_CmsXmlConfiguration#addXmlDigesterRules(org.apache.commons.digester.Digester)
 *///from   w w  w.  ja v  a  2 s .c o  m
public void addXmlDigesterRules(Digester digester) {

    // add finish rule
    digester.addCallMethod("*/" + N_WORKPLACE, "initializeFinished");

    // generic <param> parameter rules
    digester.addCallMethod("*/" + I_CmsXmlConfiguration.N_PARAM,
            I_CmsConfigurationParameterHandler.ADD_PARAMETER_METHOD, 2);
    digester.addCallParam("*/" + I_CmsXmlConfiguration.N_PARAM, 0, I_CmsXmlConfiguration.A_NAME);
    digester.addCallParam("*/" + I_CmsXmlConfiguration.N_PARAM, 1);

    // creation of the import/export manager        
    digester.addObjectCreate("*/" + N_WORKPLACE, CmsWorkplaceManager.class);
    // import/export manager finished
    digester.addSetNext("*/" + N_WORKPLACE, "setWorkplaceManager");

    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_USER_LISTS, "setUserListMode", 1);
    digester.addCallParam("*/" + N_WORKPLACE + "/" + N_USER_LISTS, 0, A_MODE);

    // add default locale rule
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_DEFAULTLOCALE, "setDefaultLocale", 0);

    // add default properties on structure setting
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_DEFAULTPROPERTIESONSTRUCTURE,
            "setDefaultPropertiesOnStructure", 0);

    // add default properties on structure setting
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_ENABLEADVANCEDPROPERTYTABS,
            "setEnableAdvancedPropertyTabs", 0);

    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_GROUP_TRANSLATION, "setGroupTranslationClass", 1);
    digester.addCallParam("*/" + N_WORKPLACE + "/" + N_GROUP_TRANSLATION, 0, A_CLASS);

    // add rules for dialog handlers
    digester.addObjectCreate("*/" + N_WORKPLACE + "/" + N_DIALOGHANDLERS + "/" + N_DIALOGHANDLER, A_CLASS,
            CmsConfigurationException.class);
    digester.addSetNext("*/" + N_WORKPLACE + "/" + N_DIALOGHANDLERS + "/" + N_DIALOGHANDLER,
            "addDialogHandler");
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_DIALOGHANDLERS + "/" + N_DIALOGHANDLER,
            I_CmsConfigurationParameterHandler.INIT_CONFIGURATION_METHOD);

    // add rules for editor handler
    digester.addObjectCreate("*/" + N_WORKPLACE + "/" + N_EDITORHANDLER, A_CLASS,
            CmsConfigurationException.class);
    digester.addSetNext("*/" + N_WORKPLACE + "/" + N_EDITORHANDLER, "setEditorHandler");

    // add rules for editor action handler
    digester.addObjectCreate("*/" + N_WORKPLACE + "/" + N_EDITORACTION, A_CLASS,
            CmsConfigurationException.class);
    digester.addSetNext("*/" + N_WORKPLACE + "/" + N_EDITORACTION, "setEditorAction");

    // add rules for editor css handler classes
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_EDITORCSSHANDLERS + "/" + N_EDITORCSSHANDLER,
            "addEditorCssHandler", 1);
    digester.addCallParam("*/" + N_WORKPLACE + "/" + N_EDITORCSSHANDLERS + "/" + N_EDITORCSSHANDLER, 0,
            A_CLASS);

    // add rules for pre editor action classes
    digester.addObjectCreate("*/" + N_WORKPLACE + "/" + N_EDITORPRECONDITIONS + "/" + N_EDITORPRECONDITION,
            A_CLASS, CmsConfigurationException.class);
    digester.addSetNext("*/" + N_WORKPLACE + "/" + N_EDITORPRECONDITIONS + "/" + N_EDITORPRECONDITION,
            "addPreEditorConditionDefinition");

    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_EDITORPRECONDITIONS + "/" + N_EDITORPRECONDITION,
            "setResourceTypeName", 1);
    digester.addCallParam("*/" + N_WORKPLACE + "/" + N_EDITORPRECONDITIONS + "/" + N_EDITORPRECONDITION, 0,
            A_NAME);

    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_EDITORPRECONDITIONS + "/" + N_EDITORPRECONDITION,
            I_CmsConfigurationParameterHandler.INIT_CONFIGURATION_METHOD);

    // add rules for direct edit provider
    digester.addObjectCreate("*/" + N_WORKPLACE + "/" + N_DIRECTEDITPROVIDER, A_CLASS,
            CmsConfigurationException.class);
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_DIRECTEDITPROVIDER,
            I_CmsConfigurationParameterHandler.INIT_CONFIGURATION_METHOD);
    digester.addSetNext("*/" + N_WORKPLACE + "/" + N_DIRECTEDITPROVIDER, "setDirectEditProvider");

    // add rules for the workplace export points 
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_EXPORTPOINTS + "/" + N_EXPORTPOINT, "addExportPoint",
            2);
    digester.addCallParam("*/" + N_WORKPLACE + "/" + N_EXPORTPOINTS + "/" + N_EXPORTPOINT, 0, A_URI);
    digester.addCallParam("*/" + N_WORKPLACE + "/" + N_EXPORTPOINTS + "/" + N_EXPORTPOINT, 1, A_DESTINATION);

    // add autolock rule
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_AUTOLOCK, "setAutoLock", 0);

    // add XML content auto correction rule
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_XMLCONTENTAUTOCORRECTION, "setXmlContentAutoCorrect",
            0);

    // add user management enabled rule
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_ENABLEUSERMGMT, "setUserManagementEnabled", 0);

    // add max file upload size rule
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_MAXUPLOADSIZE, "setFileMaxUploadSize", 0);

    // add labeled folders rule
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_LABELEDFOLDERS + "/" + N_RESOURCE, "addLabeledFolder",
            1);
    digester.addCallParam("*/" + N_WORKPLACE + "/" + N_LABELEDFOLDERS + "/" + N_RESOURCE, 0, A_URI);

    // add localized folders rule
    digester.addCallMethod("*/" + N_WORKPLACE + "/" + N_LOCALIZEDFOLDERS + "/" + N_RESOURCE,
            "addLocalizedFolder", 1);
    digester.addCallParam("*/" + N_WORKPLACE + "/" + N_LOCALIZEDFOLDERS + "/" + N_RESOURCE, 0, A_URI);

    // add fileViewSettings rules
    String xPathPrefix = "*/" + N_RFSFILEVIEWESETTINGS;
    digester.addObjectCreate(xPathPrefix, CmsRfsFileViewer.class);
    digester.addBeanPropertySetter(xPathPrefix + "/" + N_ROOTPATH);
    digester.addBeanPropertySetter(xPathPrefix + "/" + N_FILEPATH);
    digester.addBeanPropertySetter(xPathPrefix + "/" + N_ENABLED);
    digester.addBeanPropertySetter(xPathPrefix + "/" + N_FILEENCODING);
    digester.addBeanPropertySetter(xPathPrefix + "/" + N_ISLOGFILE);
    digester.addBeanPropertySetter(xPathPrefix + "/" + N_WINDOWSIZE);

    // Cms specific rule similar to SetNextRule with implicit first CmsObject argument (remains null). 
    digester.addRule(xPathPrefix, new CmsSetNextRule("setFileViewSettings", CmsRfsFileViewer.class));

    // add explorer type rules
    addExplorerTypeXmlRules(digester);
    addDefaultAccessControlRules(digester);
    addMultiContextMenuRules(digester);
    addContextMenuRules(digester);
    addUserInfoRules(digester);
    addDefaultPreferencesRules(digester);

    // the customized workplace foot
    xPathPrefix = "*/" + N_WORKPLACE + "/" + N_WORKPLACECUSTOMFOOT;
    digester.addObjectCreate(xPathPrefix, CmsWorkplaceCustomFoot.class);
    digester.addCallMethod(xPathPrefix + "/" + N_BACKGROUNDCOLOR, "setBackgroundColor", 0);
    digester.addCallMethod(xPathPrefix + "/" + N_COLOR, "setColor", 0);
    digester.addCallMethod(xPathPrefix + "/" + N_TEXT, "setText", 2);
    digester.addCallParam(xPathPrefix + "/" + N_TEXT, 0);
    digester.addCallParam(xPathPrefix + "/" + N_TEXT, 1, A_REPLACE);
    digester.addSetNext(xPathPrefix, "setCustomFoot");

    addToolManagerRules(digester);

}