org.apache.commons.digester.Digester

Here are the examples of the java api org.apache.commons.digester.Digester taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

81 Examples 7

19 Source : PartComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@Override
public void configureDigester(Digester digester) {
    addSubreportRules(digester);
}

19 Source : JRBaseFactory.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

/**
 * @author Teodor Danciu ([email protected])
 */
public abstract clreplaced JRBaseFactory implements ObjectCreationFactory {

    public static final String EXCEPTION_MESSAGE_KEY_UNKNOWN_REPORT_STYLE = "xml.base.factory.unknown.report.style";

    /**
     */
    protected transient Digester digester;

    @Override
    public Digester getDigester() {
        return this.digester;
    }

    @Override
    public void setDigester(Digester digester) {
        this.digester = digester;
    }
}

19 Source : SpiderChartDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@Override
public void configureDigester(Digester digester) {
    addSpiderChartRules(digester);
}

19 Source : SortComponentDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@Override
public void configureDigester(Digester digester) {
    addSortComponentRules(digester);
}

19 Source : IconLabelComponentDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@Override
public void configureDigester(Digester digester) {
    addIconLabelComponentRules(digester);
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected void addBarcode4jRules(Digester digester) {
    addBaseBarcode4jRules(digester, "*/componentElement/Codabar", CodabarComponent.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/Code128", Code128Component.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/EAN128", EAN128Component.clreplaced);
    addTemplateRules(digester, "*/componentElement/EAN128");
    addBaseBarcode4jRules(digester, "*/componentElement/DataMatrix", DataMatrixComponent.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/RoyalMailCustomer", RoyalMailCustomerComponent.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/USPSIntelligentMail", USPSIntelligentMailComponent.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/Code39", Code39Component.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/Interleaved2Of5", Interleaved2Of5Component.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/UPCA", UPCAComponent.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/UPCE", UPCEComponent.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/EAN13", EAN13Component.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/EAN8", EAN8Component.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/POSTNET", POSTNETComponent.clreplaced);
    addBaseBarcode4jRules(digester, "*/componentElement/PDF417", PDF417Component.clreplaced);
    addQRCodeRules(digester, "*/componentElement/QRCode", QRCodeComponent.clreplaced);
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@SuppressWarnings("deprecation")
protected void addTableRowRules(Digester digester, String pattern, String setNextMethod) {
    digester.addObjectCreate(pattern, StandardRow.clreplaced);
    digester.addSetProperties(pattern);
    digester.addSetNext(pattern, setNextMethod);
    addExpressionRules(digester, pattern + "/printWhenExpression", JRExpressionFactory.BooleanExpressionFactory.clreplaced, "setPrintWhenExpression", true);
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@SuppressWarnings("deprecation")
protected <T> void addPatternExpressionRules(Digester digester, String barcodePattern) {
    String patternExpressionPattern = barcodePattern + "/patternExpression";
    digester.addFactoryCreate(patternExpressionPattern, JRExpressionFactory.StringExpressionFactory.clreplaced.getName());
    digester.addCallMethod(patternExpressionPattern, "setText", 0);
    digester.addSetNext(patternExpressionPattern, "setPatternExpression", JRExpression.clreplaced.getName());
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@SuppressWarnings("deprecation")
protected void addTableRules(Digester digester) {
    String tablePattern = "*/componentElement/table";
    // digester.addObjectCreate(tablePattern, StandardTable.clreplaced);
    digester.addFactoryCreate(tablePattern, StandardTableFactory.clreplaced.getName());
    String columnPattern = "*/column";
    digester.addObjectCreate(columnPattern, StandardColumn.clreplaced);
    digester.addSetNext(columnPattern, "addColumn");
    digester.addSetProperties(columnPattern, // properties to be ignored by this rule
    new String[] { "uuid" }, new String[0]);
    digester.addRule(columnPattern, new UuidPropertyRule("uuid", "UUID"));
    addExpressionRules(digester, columnPattern + "/printWhenExpression", JRExpressionFactory.BooleanExpressionFactory.clreplaced, "setPrintWhenExpression", true);
    addTableCellRules(digester, columnPattern + "/tableHeader", "setTableHeader");
    addTableCellRules(digester, columnPattern + "/tableFooter", "setTableFooter");
    addTableGroupCellRules(digester, columnPattern + "/groupHeader", "addGroupHeader");
    addTableGroupCellRules(digester, columnPattern + "/groupFooter", "addGroupFooter");
    addTableCellRules(digester, columnPattern + "/columnHeader", "setColumnHeader");
    addTableCellRules(digester, columnPattern + "/columnFooter", "setColumnFooter");
    addTableCellRules(digester, columnPattern + "/detailCell", "setDetailCell");
    String columnGroupPattern = "*/columnGroup";
    digester.addObjectCreate(columnGroupPattern, StandardColumnGroup.clreplaced);
    digester.addSetNext(columnGroupPattern, "addColumn");
    digester.addSetProperties(columnGroupPattern, // properties to be ignored by this rule
    new String[] { "uuid" }, new String[0]);
    digester.addRule(columnGroupPattern, new UuidPropertyRule("uuid", "UUID"));
    addExpressionRules(digester, columnGroupPattern + "/printWhenExpression", JRExpressionFactory.BooleanExpressionFactory.clreplaced, "setPrintWhenExpression", true);
    addTableCellRules(digester, columnGroupPattern + "/tableHeader", "setTableHeader");
    addTableCellRules(digester, columnGroupPattern + "/tableFooter", "setTableFooter");
    addTableGroupCellRules(digester, columnGroupPattern + "/groupHeader", "addGroupHeader");
    addTableGroupCellRules(digester, columnGroupPattern + "/groupFooter", "addGroupFooter");
    addTableCellRules(digester, columnGroupPattern + "/columnHeader", "setColumnHeader");
    addTableCellRules(digester, columnGroupPattern + "/columnFooter", "setColumnFooter");
    addTableRowRules(digester, tablePattern + "/tableHeader", "setTableHeader");
    addTableRowRules(digester, tablePattern + "/tableFooter", "setTableFooter");
    addTableGroupRowRules(digester, tablePattern + "/groupHeader", "addGroupHeader");
    addTableGroupRowRules(digester, tablePattern + "/groupFooter", "addGroupFooter");
    addTableRowRules(digester, tablePattern + "/columnHeader", "setColumnHeader");
    addTableRowRules(digester, tablePattern + "/columnFooter", "setColumnFooter");
    addTableRowRules(digester, tablePattern + "/detail", "setDetail");
    addTableBaseCellRules(digester, tablePattern + "/noData", "setNoData");
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@Override
public void configureDigester(Digester digester) {
    addListRules(digester);
    addBarbecueRules(digester);
    addBarcode4jRules(digester);
    addTableRules(digester);
    SpiderChartDigester.addSpiderChartRules(digester);
    addMapRules(digester);
    SortComponentDigester.addSortComponentRules(digester);
    IconLabelComponentDigester.addIconLabelComponentRules(digester);
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected void addListRules(Digester digester) {
    String listPattern = "*/componentElement/list";
    digester.addObjectCreate(listPattern, StandardListComponent.clreplaced);
    digester.addSetProperties(listPattern, // properties to be ignored by this rule
    new String[] { "printOrder" }, new String[0]);
    digester.addRule(listPattern, new XmlConstantPropertyRule("printOrder", "printOrderValue", PrintOrderEnum.values()));
    String listContentsPattern = listPattern + "/listContents";
    digester.addObjectCreate(listContentsPattern, DesignListContents.clreplaced);
    digester.addSetProperties(listContentsPattern);
    digester.addSetNext(listContentsPattern, "setContents");
    // rule to set the context dataset name
    digester.addRule(listContentsPattern, new DatasetRunReportContextRule<>(ListComponent.clreplaced));
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@SuppressWarnings("deprecation")
protected <T> void addBarcodeRules(Digester digester, String barcodePattern, Clreplaced<T> barcodeComponentClreplaced, String[] ignoredProperties) {
    digester.addObjectCreate(barcodePattern, barcodeComponentClreplaced);
    digester.addSetProperties(barcodePattern, // properties to be ignored by this rule
    ignoredProperties, new String[0]);
    // rule to set evaluation time
    digester.addRule(barcodePattern, new XmlConstantPropertyRule(JRXmlConstants.ATTRIBUTE_evaluationTime, "evaluationTimeValue", EvaluationTimeEnum.values()));
    String codeExpressionPattern = barcodePattern + "/codeExpression";
    digester.addFactoryCreate(codeExpressionPattern, JRExpressionFactory.StringExpressionFactory.clreplaced.getName());
    digester.addCallMethod(codeExpressionPattern, "setText", 0);
    digester.addSetNext(codeExpressionPattern, "setCodeExpression", JRExpression.clreplaced.getName());
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected void addItemRules(Digester digester, String itemPattern, String namespace) {
    digester.addFactoryCreate(itemPattern, ItemXmlFactory.clreplaced.getName());
    digester.addSetNext(itemPattern, "addItem", Item.clreplaced.getName());
    String locationItemPropertyPattern = itemPattern + "/itemProperty";
    digester.addFactoryCreate(locationItemPropertyPattern, ItemPropertyXmlFactory.clreplaced.getName());
    digester.addSetNext(locationItemPropertyPattern, "addItemProperty", ItemProperty.clreplaced.getName());
    digester.setRuleNamespaceURI(namespace);
    String locationItemPropertyValueExpressionPattern = locationItemPropertyPattern + "/" + JRXmlConstants.ELEMENT_valueExpression;
    digester.addFactoryCreate(locationItemPropertyValueExpressionPattern, JRExpressionFactory.clreplaced.getName());
    digester.addCallMethod(locationItemPropertyValueExpressionPattern, "setText", 0);
    digester.addSetNext(locationItemPropertyValueExpressionPattern, "setValueExpression", JRExpression.clreplaced.getName());
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected void addTableGroupRowRules(Digester digester, String pattern, String setNextMethod) {
    digester.addObjectCreate(pattern, StandardGroupRow.clreplaced);
    digester.addSetProperties(pattern);
    addTableRowRules(digester, pattern + "/row", "setRow");
    digester.addSetNext(pattern, setNextMethod);
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@SuppressWarnings("deprecation")
protected void addTemplateRules(Digester digester, String barcodePattern) {
    String templateExpressionPattern = barcodePattern + "/templateExpression";
    digester.addFactoryCreate(templateExpressionPattern, JRExpressionFactory.StringExpressionFactory.clreplaced.getName());
    digester.addCallMethod(templateExpressionPattern, "setText", 0);
    digester.addSetNext(templateExpressionPattern, "setTemplateExpression", JRExpression.clreplaced.getName());
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@SuppressWarnings("deprecation")
protected void addBarbecueRules(Digester digester) {
    String barcodePattern = "*/componentElement/barbecue";
    digester.addObjectCreate(barcodePattern, StandardBarbecueComponent.clreplaced);
    digester.addSetProperties(barcodePattern, // properties to be ignored by this rule
    new String[] { JRXmlConstants.ATTRIBUTE_evaluationTime, StandardBarbecueComponent.PROPERTY_ROTATION }, new String[0]);
    digester.addRule(barcodePattern, new XmlConstantPropertyRule(JRXmlConstants.ATTRIBUTE_evaluationTime, "evaluationTimeValue", EvaluationTimeEnum.values()));
    digester.addRule(barcodePattern, new XmlConstantPropertyRule(StandardBarbecueComponent.PROPERTY_ROTATION, RotationEnum.values()));
    String barcodeExpressionPattern = barcodePattern + "/codeExpression";
    digester.addFactoryCreate(barcodeExpressionPattern, JRExpressionFactory.StringExpressionFactory.clreplaced.getName());
    digester.addCallMethod(barcodeExpressionPattern, "setText", 0);
    digester.addSetNext(barcodeExpressionPattern, "setCodeExpression", JRExpression.clreplaced.getName());
    String applicationIdentifierExpressionPattern = barcodePattern + "/applicationIdentifierExpression";
    digester.addFactoryCreate(applicationIdentifierExpressionPattern, JRExpressionFactory.StringExpressionFactory.clreplaced.getName());
    digester.addCallMethod(applicationIdentifierExpressionPattern, "setText", 0);
    digester.addSetNext(applicationIdentifierExpressionPattern, "setApplicationIdentifierExpression", JRExpression.clreplaced.getName());
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected <T> void addQRCodeRules(Digester digester, String barcodePattern, Clreplaced<T> barcodeComponentClreplaced) {
    addBarcodeRules(digester, barcodePattern, barcodeComponentClreplaced, QRCODE_IGNORED_PROPERTIES);
    digester.addRule(barcodePattern, new XmlConstantPropertyRule("errorCorrectionLevel", "errorCorrectionLevel", ErrorCorrectionLevelEnum.values()));
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected <T> void addBaseBarcode4jRules(Digester digester, String barcodePattern, Clreplaced<T> barcodeComponentClreplaced) {
    addBarcodeRules(digester, barcodePattern, barcodeComponentClreplaced, BARCODE4J_IGNORED_PROPERTIES);
    addPatternExpressionRules(digester, barcodePattern);
    digester.addRule(barcodePattern, new OrientationRule("orientation", "orientation"));
    digester.addRule(barcodePattern, new XmlConstantPropertyRule("textPosition", "textPosition", TextPositionEnum.values()));
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected void addTableCellRules(Digester digester, String pattern, String setNextMethod) {
    digester.addObjectCreate(pattern, DesignCell.clreplaced);
    digester.addSetNext(pattern, setNextMethod);
    // rule to set the context dataset name
    digester.addRule(pattern, new DatasetRunReportContextRule<>(TableComponent.clreplaced));
    digester.addSetProperties(pattern, new String[] { JRXmlConstants.ATTRIBUTE_style }, new String[0]);
    digester.addRule(pattern, new StyleContainerRule());
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected void addTableGroupCellRules(Digester digester, String pattern, String setNextMethod) {
    digester.addObjectCreate(pattern, StandardGroupCell.clreplaced);
    digester.addSetProperties(pattern);
    addTableCellRules(digester, pattern + "/cell", "setCell");
    digester.addSetNext(pattern, setNextMethod);
}

19 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected void addTableBaseCellRules(Digester digester, String pattern, String setNextMethod) {
    digester.addObjectCreate(pattern, DesignBaseCell.clreplaced);
    digester.addSetNext(pattern, setNextMethod);
    // rule to set the context dataset name
    digester.addRule(pattern, new DatasetRunReportContextRule<>(TableComponent.clreplaced));
    digester.addSetProperties(pattern, new String[] { JRXmlConstants.ATTRIBUTE_style }, new String[0]);
    digester.addRule(pattern, new StyleContainerRule());
}

19 Source : CVDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@Override
public void configureDigester(Digester digester) {
    addRules(digester);
}

19 Source : HtmlComponentDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@Override
public void configureDigester(Digester digester) {
    setHtmlComponentRules(digester);
}

19 Source : ConfigParser.java
with Apache License 2.0
from servicecatalog

/**
 * Creates the rules.
 *
 * @return The rules all put into a rule chain
 */
private LinkedList createServerList(File data) throws Exception {
    Digester digester = new Digester();
    digester.setUseContextClreplacedLoader(true);
    // Construct server list
    digester.addObjectCreate("config", LinkedList.clreplaced);
    // Create servers
    digester.addObjectCreate("config/server", null, "clreplacedName");
    digester.addSetProperties("config/server");
    // Create rule
    digester.addObjectCreate("config/server/rule", null, "clreplacedName");
    digester.addSetProperties("config/server/rule");
    digester.addSetNext("config/server/rule", "setRule");
    // Create composite rule
    digester.addObjectCreate("config/server/composite-rule", null, "clreplacedName");
    digester.addSetProperties("config/server/composite-rule");
    digester.addObjectCreate("config/server/composite-rule/rule", null, "clreplacedName");
    digester.addSetProperties("config/server/composite-rule/rule");
    digester.addSetNext("config/server/composite-rule/rule", "addRule");
    digester.addSetNext("config/server/composite-rule", "setRule");
    // Add server to list
    digester.addSetNext("config/server", "add");
    // Create cluster servers
    digester.addObjectCreate("config/cluster-server", null, "clreplacedName");
    digester.addSetProperties("config/cluster-server");
    // Create the servers in this cluster
    digester.addCallMethod("config/cluster-server/server", "addServer", 2);
    digester.addCallParam("config/cluster-server/server", 0, "domainName");
    digester.addCallParam("config/cluster-server/server", 1, "path");
    // Create rule
    digester.addObjectCreate("config/cluster-server/rule", null, "clreplacedName");
    digester.addSetProperties("config/cluster-server/rule");
    digester.addSetNext("config/cluster-server/rule", "setRule");
    // Create composite rule
    digester.addObjectCreate("config/cluster-server/composite-rule", null, "clreplacedName");
    digester.addSetProperties("config/cluster-server/composite-rule");
    digester.addObjectCreate("config/cluster-server/composite-rule/rule", null, "clreplacedName");
    digester.addSetProperties("config/cluster-server/composite-rule/rule");
    digester.addSetNext("config/cluster-server/composite-rule/rule", "addRule");
    digester.addSetNext("config/cluster-server/composite-rule", "setRule");
    // Add server to list
    digester.addSetNext("config/cluster-server", "add");
    return (LinkedList) digester.parse(data);
}

19 Source : DigesterFacesConfigUnmarshallerImpl.java
with Eclipse Public License 1.0
from OpenLiberty

/**
 * @author <a href="mailto:[email protected]">Oliver Rossmueller</a>
 */
public clreplaced DigesterFacesConfigUnmarshallerImpl implements FacesConfigUnmarshaller<FacesConfigImpl> {

    private Digester digester;

    public DigesterFacesConfigUnmarshallerImpl(ExternalContext externalContext) {
        digester = new Digester();
        // TODO: validation set to false during implementation of 1.2
        digester.setValidating(false);
        digester.setNamespaceAware(true);
        digester.setEnreplacedyResolver(new FacesConfigEnreplacedyResolver(externalContext));
        // digester.setUseContextClreplacedLoader(true);
        digester.setClreplacedLoader(ClreplacedUtils.getContextClreplacedLoader());
        digester.addObjectCreate("faces-config", FacesConfigImpl.clreplaced);
        // 2.0 specific start
        digester.addSetProperties("faces-config", "metadata-complete", "metadataComplete");
        digester.addSetProperties("faces-config", "version", "version");
        // 2.0 specific end
        // 2.0 config ordering name start
        digester.addCallMethod("faces-config/protected-views/url-pattern", "addProtectedViewUrlPattern", 0);
        digester.addCallMethod("faces-config/name", "setName", 0);
        digester.addObjectCreate("faces-config/ordering", OrderingImpl.clreplaced);
        digester.addSetNext("faces-config/ordering", "setOrdering");
        digester.addObjectCreate("faces-config/ordering/before/name", FacesConfigNameSlotImpl.clreplaced);
        digester.addSetNext("faces-config/ordering/before/name", "addBeforeSlot");
        digester.addCallMethod("faces-config/ordering/before/name", "setName", 0);
        digester.addObjectCreate("faces-config/ordering/before/others", ConfigOthersSlotImpl.clreplaced);
        digester.addSetNext("faces-config/ordering/before/others", "addBeforeSlot");
        digester.addObjectCreate("faces-config/ordering/after/name", FacesConfigNameSlotImpl.clreplaced);
        digester.addSetNext("faces-config/ordering/after/name", "addAfterSlot");
        digester.addCallMethod("faces-config/ordering/after/name", "setName", 0);
        digester.addObjectCreate("faces-config/ordering/after/others", ConfigOthersSlotImpl.clreplaced);
        digester.addSetNext("faces-config/ordering/after/others", "addAfterSlot");
        digester.addObjectCreate("faces-config/absolute-ordering", AbsoluteOrderingImpl.clreplaced);
        digester.addSetNext("faces-config/absolute-ordering", "setAbsoluteOrdering");
        digester.addObjectCreate("faces-config/absolute-ordering/name", FacesConfigNameSlotImpl.clreplaced);
        digester.addSetNext("faces-config/absolute-ordering/name", "addOrderSlot");
        digester.addCallMethod("faces-config/absolute-ordering/name", "setName", 0);
        digester.addObjectCreate("faces-config/absolute-ordering/others", ConfigOthersSlotImpl.clreplaced);
        digester.addSetNext("faces-config/absolute-ordering/others", "addOrderSlot");
        // 2.0 config ordering name end
        digester.addObjectCreate("faces-config/application", ApplicationImpl.clreplaced);
        digester.addSetNext("faces-config/application", "addApplication");
        digester.addCallMethod("faces-config/application/action-listener", "addActionListener", 0);
        digester.addCallMethod("faces-config/application/default-render-kit-id", "addDefaultRenderkitId", 0);
        digester.addCallMethod("faces-config/application/default-validators", "setDefaultValidatorsPresent");
        digester.addCallMethod("faces-config/application/default-validators/validator-id", "addDefaultValidatorId", 0);
        digester.addCallMethod("faces-config/application/message-bundle", "addMessageBundle", 0);
        digester.addCallMethod("faces-config/application/navigation-handler", "addNavigationHandler", 0);
        digester.addCallMethod("faces-config/application/partial-traversal", "addPartialTraversal", 0);
        digester.addCallMethod("faces-config/application/view-handler", "addViewHandler", 0);
        digester.addCallMethod("faces-config/application/state-manager", "addStateManager", 0);
        digester.addCallMethod("faces-config/application/property-resolver", "addPropertyResolver", 0);
        digester.addCallMethod("faces-config/application/variable-resolver", "addVariableResolver", 0);
        digester.addObjectCreate("faces-config/application/locale-config", LocaleConfigImpl.clreplaced);
        digester.addSetNext("faces-config/application/locale-config", "addLocaleConfig");
        digester.addCallMethod("faces-config/application/locale-config/default-locale", "setDefaultLocale", 0);
        digester.addCallMethod("faces-config/application/locale-config/supported-locale", "addSupportedLocale", 0);
        // 1.2 specific start
        digester.addCallMethod("faces-config/application/el-resolver", "addElResolver", 0);
        digester.addObjectCreate("faces-config/application/resource-bundle", ResourceBundleImpl.clreplaced);
        digester.addSetNext("faces-config/application/resource-bundle", "addResourceBundle");
        digester.addCallMethod("faces-config/application/resource-bundle/base-name", "setBaseName", 0);
        digester.addCallMethod("faces-config/application/resource-bundle/var", "setVar", 0);
        digester.addCallMethod("faces-config/application/resource-bundle/display-name", "setDisplayName", 0);
        // 1.2 specific end
        // 2.0 specific start
        digester.addObjectCreate("faces-config/application/system-event-listener", SystemEventListenerImpl.clreplaced);
        digester.addSetNext("faces-config/application/system-event-listener", "addSystemEventListener");
        digester.addCallMethod("faces-config/application/system-event-listener/system-event-listener-clreplaced", "setSystemEventListenerClreplaced", 0);
        digester.addCallMethod("faces-config/application/system-event-listener/system-event-clreplaced", "setSystemEventClreplaced", 0);
        digester.addCallMethod("faces-config/application/system-event-listener/source-clreplaced", "setSourceClreplaced", 0);
        digester.addCallMethod("faces-config/application/resource-handler", "addResourceHandler", 0);
        digester.addCallMethod("faces-config/factory/exception-handler-factory", "addExceptionHandlerFactory", 0);
        digester.addCallMethod("faces-config/factory/external-context-factory", "addExternalContextFactory", 0);
        digester.addCallMethod("faces-config/factory/view-declaration-language-factory", "addViewDeclarationLanguageFactory", 0);
        digester.addCallMethod("faces-config/factory/partial-view-context-factory", "addPartialViewContextFactory", 0);
        digester.addCallMethod("faces-config/factory/tag-handler-delegate-factory", "addTagHandlerDelegateFactory", 0);
        digester.addCallMethod("faces-config/factory/visit-context-factory", "addVisitContextFactory", 0);
        // 2.0 specific end
        digester.addObjectCreate("faces-config/application/resource-library-contracts/contract-mapping", ContractMappingImpl.clreplaced);
        digester.addSetNext("faces-config/application/resource-library-contracts/contract-mapping", "addResourceLibraryContractMapping");
        digester.addCallMethod("faces-config/application/resource-library-contracts/contract-mapping/url-pattern", "addUrlPattern", 0);
        digester.addCallMethod("faces-config/application/resource-library-contracts/contract-mapping/contracts", "addContract", 0);
        // 2.1 specific start
        digester.addCallMethod("faces-config/factory/facelet-cache-factory", "addFaceletCacheFactory", 0);
        // 2.1 specific end
        // 2.2 specific start
        digester.addCallMethod("faces-config/factory/flash-factory", "addFlashFactory", 0);
        // Note there is no client-window-factory, this factory can be set only using SPI.
        digester.addCallMethod("faces-config/factory/flow-handler-factory", "addFlowHandlerFactory", 0);
        // 2.2 specific end
        digester.addObjectCreate("faces-config/factory", FactoryImpl.clreplaced);
        digester.addSetNext("faces-config/factory", "addFactory");
        digester.addCallMethod("faces-config/factory/application-factory", "addApplicationFactory", 0);
        digester.addCallMethod("faces-config/factory/faces-context-factory", "addFacesContextFactory", 0);
        digester.addCallMethod("faces-config/factory/lifecycle-factory", "addLifecycleFactory", 0);
        digester.addCallMethod("faces-config/factory/render-kit-factory", "addRenderkitFactory", 0);
        digester.addCallMethod("faces-config/component", "addComponent", 2);
        digester.addCallParam("faces-config/component/component-type", 0);
        digester.addCallParam("faces-config/component/component-clreplaced", 1);
        digester.addObjectCreate("faces-config/converter", ConverterImpl.clreplaced);
        digester.addSetNext("faces-config/converter", "addConverter");
        digester.addCallMethod("faces-config/converter/converter-id", "setConverterId", 0);
        digester.addCallMethod("faces-config/converter/converter-for-clreplaced", "setForClreplaced", 0);
        digester.addCallMethod("faces-config/converter/converter-clreplaced", "setConverterClreplaced", 0);
        digester.addObjectCreate("faces-config/converter/attribute", AttributeImpl.clreplaced);
        digester.addSetNext("faces-config/converter/attribute", "addAttribute");
        digester.addCallMethod("faces-config/converter/attribute/description", "addDescription", 0);
        digester.addCallMethod("faces-config/converter/attribute/display-name", "addDisplayName", 0);
        digester.addCallMethod("faces-config/converter/attribute/icon", "addIcon", 0);
        digester.addCallMethod("faces-config/converter/attribute/attribute-name", "setAttributeName", 0);
        digester.addCallMethod("faces-config/converter/attribute/attribute-clreplaced", "setAttributeClreplaced", 0);
        digester.addCallMethod("faces-config/converter/attribute/default-value", "setDefaultValue", 0);
        digester.addCallMethod("faces-config/converter/attribute/suggested-value", "setSuggestedValue", 0);
        digester.addCallMethod("faces-config/converter/attribute/attribute-extension", "addAttributeExtension", 0);
        digester.addObjectCreate("faces-config/converter/property", PropertyImpl.clreplaced);
        digester.addSetNext("faces-config/converter/property", "addProperty");
        digester.addCallMethod("faces-config/converter/property/description", "addDescription", 0);
        digester.addCallMethod("faces-config/converter/property/display-name", "addDisplayName", 0);
        digester.addCallMethod("faces-config/converter/property/icon", "addIcon", 0);
        digester.addCallMethod("faces-config/converter/property/property-name", "setPropertyName", 0);
        digester.addCallMethod("faces-config/converter/property/property-clreplaced", "setPropertyClreplaced", 0);
        digester.addCallMethod("faces-config/converter/property/default-value", "setDefaultValue", 0);
        digester.addCallMethod("faces-config/converter/property/suggested-value", "setSuggestedValue", 0);
        digester.addCallMethod("faces-config/converter/property/property-extension", "addPropertyExtension", 0);
        digester.addObjectCreate("faces-config/managed-bean", ManagedBeanImpl.clreplaced);
        digester.addSetProperties("faces-config/managed-bean", "eager", "eager");
        digester.addSetNext("faces-config/managed-bean", "addManagedBean");
        digester.addCallMethod("faces-config/managed-bean/description", "setDescription", 0);
        digester.addCallMethod("faces-config/managed-bean/managed-bean-name", "setName", 0);
        digester.addCallMethod("faces-config/managed-bean/managed-bean-clreplaced", "setBeanClreplaced", 0);
        digester.addCallMethod("faces-config/managed-bean/managed-bean-scope", "setScope", 0);
        digester.addObjectCreate("faces-config/managed-bean/managed-property", ManagedPropertyImpl.clreplaced);
        digester.addSetNext("faces-config/managed-bean/managed-property", "addProperty");
        digester.addCallMethod("faces-config/managed-bean/managed-property/property-name", "setPropertyName", 0);
        digester.addCallMethod("faces-config/managed-bean/managed-property/property-clreplaced", "setPropertyClreplaced", 0);
        digester.addCallMethod("faces-config/managed-bean/managed-property/null-value", "setNullValue");
        digester.addCallMethod("faces-config/managed-bean/managed-property/value", "setValue", 0);
        digester.addObjectCreate("faces-config/managed-bean/managed-property/map-entries", MapEntriesImpl.clreplaced);
        digester.addSetNext("faces-config/managed-bean/managed-property/map-entries", "setMapEntries");
        digester.addCallMethod("faces-config/managed-bean/managed-property/map-entries/key-clreplaced", "setKeyClreplaced", 0);
        digester.addCallMethod("faces-config/managed-bean/managed-property/map-entries/value-clreplaced", "setValueClreplaced", 0);
        digester.addObjectCreate("faces-config/managed-bean/managed-property/map-entries/map-entry", MapEntriesImpl.Entry.clreplaced);
        digester.addSetNext("faces-config/managed-bean/managed-property/map-entries/map-entry", "addEntry");
        digester.addCallMethod("faces-config/managed-bean/managed-property/map-entries/map-entry/key", "setKey", 0);
        digester.addCallMethod("faces-config/managed-bean/managed-property/map-entries/map-entry/null-value", "setNullValue");
        digester.addCallMethod("faces-config/managed-bean/managed-property/map-entries/map-entry/value", "setValue", 0);
        digester.addObjectCreate("faces-config/managed-bean/managed-property/list-entries", ListEntriesImpl.clreplaced);
        digester.addSetNext("faces-config/managed-bean/managed-property/list-entries", "setListEntries");
        digester.addCallMethod("faces-config/managed-bean/managed-property/list-entries/value-clreplaced", "setValueClreplaced", 0);
        digester.addObjectCreate("faces-config/managed-bean/managed-property/list-entries/null-value", ListEntriesImpl.Entry.clreplaced);
        digester.addSetNext("faces-config/managed-bean/managed-property/list-entries/null-value", "addEntry");
        digester.addCallMethod("faces-config/managed-bean/managed-property/list-entries/null-value", "setNullValue");
        digester.addObjectCreate("faces-config/managed-bean/managed-property/list-entries/value", ListEntriesImpl.Entry.clreplaced);
        digester.addSetNext("faces-config/managed-bean/managed-property/list-entries/value", "addEntry");
        digester.addCallMethod("faces-config/managed-bean/managed-property/list-entries/value", "setValue", 0);
        digester.addObjectCreate("faces-config/managed-bean/map-entries", MapEntriesImpl.clreplaced);
        digester.addSetNext("faces-config/managed-bean/map-entries", "setMapEntries");
        digester.addCallMethod("faces-config/managed-bean/map-entries/key-clreplaced", "setKeyClreplaced", 0);
        digester.addCallMethod("faces-config/managed-bean/map-entries/value-clreplaced", "setValueClreplaced", 0);
        digester.addObjectCreate("faces-config/managed-bean/map-entries/map-entry", MapEntriesImpl.Entry.clreplaced);
        digester.addSetNext("faces-config/managed-bean/map-entries/map-entry", "addEntry");
        digester.addCallMethod("faces-config/managed-bean/map-entries/map-entry/key", "setKey", 0);
        digester.addCallMethod("faces-config/managed-bean/map-entries/map-entry/null-value", "setNullValue");
        digester.addCallMethod("faces-config/managed-bean/map-entries/map-entry/value", "setValue", 0);
        digester.addObjectCreate("faces-config/managed-bean/list-entries", ListEntriesImpl.clreplaced);
        digester.addSetNext("faces-config/managed-bean/list-entries", "setListEntries");
        digester.addCallMethod("faces-config/managed-bean/list-entries/value-clreplaced", "setValueClreplaced", 0);
        digester.addObjectCreate("faces-config/managed-bean/list-entries/null-value", ListEntriesImpl.Entry.clreplaced);
        digester.addSetNext("faces-config/managed-bean/list-entries/null-value", "addEntry");
        digester.addCallMethod("faces-config/managed-bean/list-entries/null-value", "setNullValue");
        digester.addObjectCreate("faces-config/managed-bean/list-entries/value", ListEntriesImpl.Entry.clreplaced);
        digester.addSetNext("faces-config/managed-bean/list-entries/value", "addEntry");
        digester.addCallMethod("faces-config/managed-bean/list-entries/value", "setValue", 0);
        digester.addObjectCreate("faces-config/navigation-rule", NavigationRuleImpl.clreplaced);
        digester.addSetNext("faces-config/navigation-rule", "addNavigationRule");
        digester.addCallMethod("faces-config/navigation-rule/from-view-id", "setFromViewId", 0);
        digester.addObjectCreate("faces-config/navigation-rule/navigation-case", NavigationCaseImpl.clreplaced);
        digester.addSetNext("faces-config/navigation-rule/navigation-case", "addNavigationCase");
        digester.addCallMethod("faces-config/navigation-rule/navigation-case/from-action", "setFromAction", 0);
        digester.addCallMethod("faces-config/navigation-rule/navigation-case/from-outcome", "setFromOutcome", 0);
        digester.addCallMethod("faces-config/navigation-rule/navigation-case/if", "setIf", 0);
        digester.addCallMethod("faces-config/navigation-rule/navigation-case/to-view-id", "setToViewId", 0);
        digester.addObjectCreate("faces-config/navigation-rule/navigation-case/redirect", RedirectImpl.clreplaced);
        digester.addSetProperties("faces-config/navigation-rule/navigation-case/redirect", "include-view-params", "includeViewParams");
        digester.addSetNext("faces-config/navigation-rule/navigation-case/redirect", "setRedirect");
        digester.addObjectCreate("faces-config/navigation-rule/navigation-case/redirect/view-param", ViewParamImpl.clreplaced);
        digester.addSetNext("faces-config/navigation-rule/navigation-case/redirect/view-param", "addViewParam");
        digester.addCallMethod("faces-config/navigation-rule/navigation-case/redirect/view-param/name", "setName", 0);
        digester.addCallMethod("faces-config/navigation-rule/navigation-case/redirect/view-param/value", "setValue", 0);
        digester.addObjectCreate("faces-config/navigation-rule/navigation-case/redirect/redirect-param", ViewParamImpl.clreplaced);
        digester.addSetNext("faces-config/navigation-rule/navigation-case/redirect/redirect-param", "addViewParam");
        digester.addCallMethod("faces-config/navigation-rule/navigation-case/redirect/redirect-param/name", "setName", 0);
        digester.addCallMethod("faces-config/navigation-rule/navigation-case/redirect/redirect-param/value", "setValue", 0);
        digester.addObjectCreate("faces-config/render-kit", RenderKitImpl.clreplaced);
        digester.addSetNext("faces-config/render-kit", "addRenderKit");
        digester.addCallMethod("faces-config/render-kit/render-kit-id", "setId", 0);
        // digester.addCallMethod("faces-config/render-kit/render-kit-clreplaced", "setRenderKitClreplaced", 0);
        digester.addCallMethod("faces-config/render-kit/render-kit-clreplaced", "addRenderKitClreplaced", 0);
        digester.addObjectCreate("faces-config/render-kit/renderer", RendererImpl.clreplaced);
        digester.addSetNext("faces-config/render-kit/renderer", "addRenderer");
        digester.addCallMethod("faces-config/render-kit/renderer/component-family", "setComponentFamily", 0);
        digester.addCallMethod("faces-config/render-kit/renderer/renderer-type", "setRendererType", 0);
        digester.addCallMethod("faces-config/render-kit/renderer/renderer-clreplaced", "setRendererClreplaced", 0);
        digester.addObjectCreate("faces-config/render-kit/client-behavior-renderer", ClientBehaviorRendererImpl.clreplaced);
        digester.addSetNext("faces-config/render-kit/client-behavior-renderer", "addClientBehaviorRenderer");
        digester.addCallMethod("faces-config/render-kit/client-behavior-renderer/client-behavior-renderer-type", "setRendererType", 0);
        digester.addCallMethod("faces-config/render-kit/client-behavior-renderer/client-behavior-renderer-clreplaced", "setRendererClreplaced", 0);
        // 2.0 behavior start
        digester.addObjectCreate("faces-config/behavior", BehaviorImpl.clreplaced);
        digester.addSetNext("faces-config/behavior", "addBehavior");
        digester.addCallMethod("faces-config/behavior/behavior-id", "setBehaviorId", 0);
        digester.addCallMethod("faces-config/behavior/behavior-clreplaced", "setBehaviorClreplaced", 0);
        digester.addObjectCreate("faces-config/behavior/attribute", AttributeImpl.clreplaced);
        digester.addSetNext("faces-config/behavior/attribute", "addAttribute");
        digester.addCallMethod("faces-config/behavior/attribute/description", "addDescription", 0);
        digester.addCallMethod("faces-config/behavior/attribute/display-name", "addDisplayName", 0);
        digester.addCallMethod("faces-config/behavior/attribute/icon", "addIcon", 0);
        digester.addCallMethod("faces-config/behavior/attribute/attribute-name", "setAttributeName", 0);
        digester.addCallMethod("faces-config/behavior/attribute/attribute-clreplaced", "setAttributeClreplaced", 0);
        digester.addCallMethod("faces-config/behavior/attribute/default-value", "setDefaultValue", 0);
        digester.addCallMethod("faces-config/behavior/attribute/suggested-value", "setSuggestedValue", 0);
        digester.addCallMethod("faces-config/behavior/attribute/attribute-extension", "addAttributeExtension", 0);
        digester.addObjectCreate("faces-config/behavior/property", PropertyImpl.clreplaced);
        digester.addSetNext("faces-config/behavior/property", "addProperty");
        digester.addCallMethod("faces-config/behavior/property/description", "addDescription", 0);
        digester.addCallMethod("faces-config/behavior/property/display-name", "addDisplayName", 0);
        digester.addCallMethod("faces-config/behavior/property/icon", "addIcon", 0);
        digester.addCallMethod("faces-config/behavior/property/property-name", "setPropertyName", 0);
        digester.addCallMethod("faces-config/behavior/property/property-clreplaced", "setPropertyClreplaced", 0);
        digester.addCallMethod("faces-config/behavior/property/default-value", "setDefaultValue", 0);
        digester.addCallMethod("faces-config/behavior/property/suggested-value", "setSuggestedValue", 0);
        digester.addCallMethod("faces-config/behavior/property/property-extension", "addPropertyExtension", 0);
        // 2.0 behavior end
        digester.addCallMethod("faces-config/lifecycle/phase-listener", "addLifecyclePhaseListener", 0);
        digester.addCallMethod("faces-config/validator", "addValidator", 2);
        digester.addCallParam("faces-config/validator/validator-id", 0);
        digester.addCallParam("faces-config/validator/validator-clreplaced", 1);
        // 2.1 facelets-processing start
        digester.addObjectCreate("faces-config/faces-config-extension", FacesConfigExtensionImpl.clreplaced);
        digester.addSetNext("faces-config/faces-config-extension", "addFacesConfigExtension");
        digester.addObjectCreate("faces-config/faces-config-extension/facelets-processing", FaceletsProcessingImpl.clreplaced);
        digester.addSetNext("faces-config/faces-config-extension/facelets-processing", "addFaceletsProcessing");
        digester.addCallMethod("faces-config/faces-config-extension/facelets-processing/file-extension", "setFileExtension", 0);
        digester.addCallMethod("faces-config/faces-config-extension/facelets-processing/process-as", "setProcessAs", 0);
        // 2.1 facelets-processing end
        // MyFaces specific facelets-processing instruction.
        digester.addCallMethod("faces-config/faces-config-extension/facelets-processing/oam-compress-spaces", "setOamCompressSpaces", 0);
        addFacesFlowRules(externalContext);
    }

    private void addNavigationRules(ExternalContext externalContext, String prefix, String method) {
        digester.addObjectCreate(prefix, NavigationRuleImpl.clreplaced);
        digester.addSetNext(prefix, method);
        digester.addCallMethod(prefix + "/from-view-id", "setFromViewId", 0);
        addNavigationCases(externalContext, prefix + "/navigation-case", "addNavigationCase");
    }

    private void addNavigationCases(ExternalContext externalContext, String prefix, String method) {
        digester.addObjectCreate(prefix, NavigationCaseImpl.clreplaced);
        digester.addSetNext(prefix, method);
        digester.addCallMethod(prefix + "/from-action", "setFromAction", 0);
        digester.addCallMethod(prefix + "/from-outcome", "setFromOutcome", 0);
        digester.addCallMethod(prefix + "/if", "setIf", 0);
        digester.addCallMethod(prefix + "/to-view-id", "setToViewId", 0);
        digester.addObjectCreate(prefix + "/redirect", RedirectImpl.clreplaced);
        digester.addSetProperties(prefix + "/redirect", "include-view-params", "includeViewParams");
        digester.addSetNext(prefix + "/redirect", "setRedirect");
        digester.addObjectCreate(prefix + "/redirect/view-param", ViewParamImpl.clreplaced);
        digester.addSetNext(prefix + "/redirect/view-param", "addViewParam");
        digester.addCallMethod(prefix + "/redirect/view-param/name", "setName", 0);
        digester.addCallMethod(prefix + "/redirect/view-param/value", "setValue", 0);
        digester.addObjectCreate(prefix + "/redirect/redirect-param", ViewParamImpl.clreplaced);
        digester.addSetNext(prefix + "/redirect/redirect-param", "addViewParam");
        digester.addCallMethod(prefix + "/redirect/redirect-param/name", "setName", 0);
        digester.addCallMethod(prefix + "/redirect/redirect-param/value", "setValue", 0);
    }

    private void addFacesFlowRules(ExternalContext externalContext) {
        digester.addObjectCreate("faces-config/flow-definition", FacesFlowDefinitionImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition", "addFacesFlowDefinition");
        digester.addSetProperties("faces-config/flow-definition", "id", "id");
        digester.addCallMethod("faces-config/flow-definition/start-node", "setStartNode", 0);
        digester.addCallMethod("faces-config/flow-definition/initializer", "setInitializer", 0);
        digester.addCallMethod("faces-config/flow-definition/finalizer", "setFinalizer", 0);
        digester.addObjectCreate("faces-config/flow-definition/view", FacesFlowViewImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/view", "addView");
        digester.addSetProperties("faces-config/flow-definition/view", "id", "id");
        digester.addCallMethod("faces-config/flow-definition/view/vdl-doreplacedent", "setVdlDoreplacedent", 0);
        digester.addObjectCreate("faces-config/flow-definition/switch", FacesFlowSwitchImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/switch", "addSwitch");
        digester.addSetProperties("faces-config/flow-definition/switch", "id", "id");
        digester.addObjectCreate("faces-config/flow-definition/switch/default-outcome", NavigationCaseImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/switch/default-outcome", "setDefaultOutcome");
        digester.addCallMethod("faces-config/flow-definition/switch/default-outcome", "setFromOutcome", 0);
        addNavigationCases(externalContext, "faces-config/flow-definition/switch/case", "addNavigationCase");
        digester.addObjectCreate("faces-config/flow-definition/flow-return", FacesFlowReturnImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/flow-return", "addReturn");
        digester.addSetProperties("faces-config/flow-definition/flow-return", "id", "id");
        digester.addObjectCreate("faces-config/flow-definition/flow-return/from-outcome", NavigationCaseImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/flow-return/from-outcome", "setNavigationCase");
        digester.addCallMethod("faces-config/flow-definition/flow-return/from-outcome", "setFromOutcome", 0);
        addNavigationRules(externalContext, "faces-config/flow-definition/navigation-rule", "addNavigationRule");
        digester.addObjectCreate("faces-config/flow-definition/flow-call", FacesFlowCallImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/flow-call", "addFlowCall");
        digester.addSetProperties("faces-config/flow-definition/flow-call", "id", "id");
        digester.addObjectCreate("faces-config/flow-definition/flow-call/flow-reference", FacesFlowReferenceImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/flow-call/flow-reference", "setFlowReference");
        digester.addCallMethod("faces-config/flow-definition/flow-call/flow-reference/flow-doreplacedent-id", "setFlowDoreplacedentId", 0);
        digester.addCallMethod("faces-config/flow-definition/flow-call/flow-reference/flow-id", "setFlowId", 0);
        digester.addObjectCreate("faces-config/flow-definition/flow-call/outbound-parameter", FacesFlowParameterImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/flow-call/outbound-parameter", "addOutboundParameter");
        digester.addCallMethod("faces-config/flow-definition/flow-call/outbound-parameter/name", "setName", 0);
        digester.addCallMethod("faces-config/flow-definition/flow-call/outbound-parameter/value", "setValue", 0);
        digester.addObjectCreate("faces-config/flow-definition/method-call", FacesFlowMethodCallImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/method-call", "addMethodCall");
        digester.addSetProperties("faces-config/flow-definition/method-call", "id", "id");
        digester.addCallMethod("faces-config/flow-definition/method-call/method", "setMethod", 0);
        digester.addCallMethod("faces-config/flow-definition/method-call/default-outcome", "setDefaultOutcome", 0);
        digester.addObjectCreate("faces-config/flow-definition/method-call/parameter", FacesFlowMethodParameterImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/method-call/parameter", "addParameter");
        digester.addCallMethod("faces-config/flow-definition/method-call/parameter/clreplaced", "setClreplacedName", 0);
        digester.addCallMethod("faces-config/flow-definition/method-call/parameter/value", "setValue", 0);
        digester.addObjectCreate("faces-config/flow-definition/inbound-parameter", FacesFlowParameterImpl.clreplaced);
        digester.addSetNext("faces-config/flow-definition/inbound-parameter", "addInboundParameter");
        digester.addCallMethod("faces-config/flow-definition/inbound-parameter/name", "setName", 0);
        digester.addCallMethod("faces-config/flow-definition/inbound-parameter/value", "setValue", 0);
        // View Pool config
        digester.addObjectCreate("faces-config/faces-config-extension/view-pool-mapping", ViewPoolMappingImpl.clreplaced);
        digester.addSetNext("faces-config/faces-config-extension/view-pool-mapping", "addViewPoolMapping");
        digester.addCallMethod("faces-config/faces-config-extension/view-pool-mapping/url-pattern", "setUrlPattern", 0);
        digester.addObjectCreate("faces-config/faces-config-extension/view-pool-mapping/parameter", ViewPoolParameterImpl.clreplaced);
        digester.addSetNext("faces-config/faces-config-extension/view-pool-mapping/parameter", "addParameter");
        digester.addCallMethod("faces-config/faces-config-extension/view-pool-mapping/parameter/name", "setName", 0);
        digester.addCallMethod("faces-config/faces-config-extension/view-pool-mapping/parameter/value", "setValue", 0);
    }

    private void postProcessFacesConfig(String systemId, FacesConfigImpl config) {
        for (org.apache.myfaces.config.element.Application application : config.getApplications()) {
            for (org.apache.myfaces.config.element.LocaleConfig localeConfig : application.getLocaleConfig()) {
                if (!localeConfig.getSupportedLocales().contains(localeConfig.getDefaultLocale())) {
                    localeConfig.getSupportedLocales().add(localeConfig.getDefaultLocale());
                }
            }
        }
        for (FacesFlowDefinition facesFlowDefinition : config.getFacesFlowDefinitions()) {
            // JSF 2.2 section 11.4.3.1 says this: "... Flows are defined using the
            // <flow-definition> element. This element must have an id attribute which uniquely
            // identifies the flow within the scope of the Application Configuration Resource
            // file in which the element appears. To enable multiple flows with the same id to
            // exist in an application, the <faces-config><name> element is taken to
            // be the definingDoreplacedentId of the flow. If no <name> element is specified,
            // the empty string is taken as the value for definingDoreplacedentId. ..."
            if (config.getName() != null) {
                ((FacesFlowDefinitionImpl) facesFlowDefinition).setDefiningDoreplacedentId(config.getName());
            } else {
                ((FacesFlowDefinitionImpl) facesFlowDefinition).setDefiningDoreplacedentId("");
            }
        }
    }

    public FacesConfigImpl getFacesConfig(InputStream in, String systemId) throws IOException, SAXException {
        InputSource is = new InputSource(in);
        is.setSystemId(systemId);
        // Fix for http://issues.apache.org/jira/browse/MYFACES-236
        FacesConfigImpl config = (FacesConfigImpl) digester.parse(is);
        postProcessFacesConfig(systemId, config);
        return config;
    }

    public FacesConfigImpl getFacesConfig(Reader r) throws IOException, SAXException {
        // InputSource is = new InputSource(in);
        // is.setSystemId(systemId);
        // Fix for http://issues.apache.org/jira/browse/MYFACES-236
        FacesConfigImpl config = (FacesConfigImpl) digester.parse(r);
        postProcessFacesConfig(null, config);
        return config;
    }
}

19 Source : ValidatorResources.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Create a <code>Rule</code> to handle <code>arg0-arg3</code>
 * elements. This will allow validation.xml files that use the
 * versions of the DTD prior to Validator 1.2.0 to continue
 * working.
 */
private void addOldArgRules(Digester digester) {
    // Create a new rule to process args elements
    Rule rule = new Rule() {

        @Override
        public void begin(String namespace, String name, Attributes attributes) throws Exception {
            // Create the Arg
            Arg arg = new Arg();
            arg.setKey(attributes.getValue("key"));
            arg.setName(attributes.getValue("name"));
            if ("false".equalsIgnoreCase(attributes.getValue("resource"))) {
                arg.setResource(false);
            }
            try {
                // skip the arg prefix
                final int length = "arg".length();
                arg.setPosition(Integer.parseInt(name.substring(length)));
            } catch (Exception ex) {
                getLog().error("Error parsing Arg position: " + name + " " + arg + " " + ex);
            }
            // Add the arg to the parent field
            ((Field) getDigester().peek(0)).addArg(arg);
        }
    };
    // Add the rule for each of the arg elements
    digester.addRule(ARGS_PATTERN + "0", rule);
    digester.addRule(ARGS_PATTERN + "1", rule);
    digester.addRule(ARGS_PATTERN + "2", rule);
    digester.addRule(ARGS_PATTERN + "3", rule);
}

19 Source : FromXmlRuleSet.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * A Digester rule set where the rules come from an XML file.
 *
 * @since 1.2
 */
public clreplaced FromXmlRuleSet extends RuleSetBase {

    public static final String DIGESTER_DTD_PATH = "org/apache/commons/digester/xmlrules/digester-rules.dtd";

    /**
     * The file containing the Digester rules, in XML.
     */
    private XMLRulesLoader rulesLoader;

    /**
     * The rule set for parsing the Digester rules
     */
    private DigesterRuleParser parser;

    /**
     * The digester for loading the rules xml.
     */
    private Digester rulesDigester;

    /**
     * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
     * rulesDigester.
     * @param rulesXml the path to the XML doreplacedent defining the Digester rules
     */
    public FromXmlRuleSet(URL rulesXml) {
        this(rulesXml, new DigesterRuleParser(), new Digester());
    }

    /**
     * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
     * a ruleDigester for loading the rules xml.
     * @param rulesXml the path to the XML doreplacedent defining the Digester rules
     * @param rulesDigester the digester to read the rules xml.
     */
    public FromXmlRuleSet(URL rulesXml, Digester rulesDigester) {
        this(rulesXml, new DigesterRuleParser(), rulesDigester);
    }

    /**
     * @param rulesXml the path to the XML doreplacedent defining the Digester rules
     * @param parser an instance of DigesterRuleParser, for parsing the rules from XML
     */
    public FromXmlRuleSet(URL rulesXml, DigesterRuleParser parser) {
        this(rulesXml, parser, new Digester());
    }

    /**
     * @param rulesXml the path to the XML doreplacedent defining the Digester rules
     * @param parser an instance of DigesterRuleParser, for parsing the rules from XML
     * @param rulesDigester the digester used to load the Xml rules.
     */
    public FromXmlRuleSet(URL rulesXml, DigesterRuleParser parser, Digester rulesDigester) {
        init(new URLXMLRulesLoader(rulesXml), parser, rulesDigester);
    }

    /**
     * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
     * rulesDigester.
     * @param inputSource load the xml rules from this InputSource
     */
    public FromXmlRuleSet(InputSource inputSource) {
        this(inputSource, new DigesterRuleParser(), new Digester());
    }

    /**
     * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
     * a ruleDigester for loading the rules xml.
     * @param inputSource load the xml rules from this InputSource
     * @param rulesDigester the digester to read the rules xml.
     */
    public FromXmlRuleSet(InputSource inputSource, Digester rulesDigester) {
        this(inputSource, new DigesterRuleParser(), rulesDigester);
    }

    /**
     * @param inputSource load the xml rules from this InputSource
     * @param parser an instance of DigesterRuleParser, for parsing the rules from XML
     */
    public FromXmlRuleSet(InputSource inputSource, DigesterRuleParser parser) {
        this(inputSource, parser, new Digester());
    }

    /**
     * @param inputSource load the xml rules from this InputSource
     * @param parser an instance of DigesterRuleParser, for parsing the rules from XML
     * @param rulesDigester the digester used to load the Xml rules.
     */
    public FromXmlRuleSet(InputSource inputSource, DigesterRuleParser parser, Digester rulesDigester) {
        init(new InputSourceXMLRulesLoader(inputSource), parser, rulesDigester);
    }

    /**
     * Base constructor
     */
    private void init(XMLRulesLoader rulesLoader, DigesterRuleParser parser, Digester rulesDigester) {
        this.rulesLoader = rulesLoader;
        this.parser = parser;
        this.rulesDigester = rulesDigester;
    }

    /**
     * Adds to the digester the set of Rule instances defined in the
     * XML file for this rule set.
     * @see org.apache.commons.digester.RuleSetBase
     */
    @Override
    public void addRuleInstances(org.apache.commons.digester.Digester digester) throws XmlLoadException {
        addRuleInstances(digester, null);
    }

    /**
     * Adds to the digester the set of Rule instances defined in the
     * XML file for this rule set.
     * <p>
     * Note that this method doesn't have a matching one on the DigesterLoader
     * clreplaced, because it is not expected to be widely used, and DigesterLoader's
     * load method is already heavily overloaded.
     *
     * @param digester is the digester that rules will be added to.
     * @param basePath is a path that will be prefixed to every
     * pattern string defined in the xmlrules input file.
     *
     * @see org.apache.commons.digester.RuleSetBase
     * @since 1.6
     */
    public void addRuleInstances(org.apache.commons.digester.Digester digester, String basePath) throws XmlLoadException {
        URL dtdURL = getClreplaced().getClreplacedLoader().getResource(DIGESTER_DTD_PATH);
        if (dtdURL == null) {
            throw new XmlLoadException("Cannot find resource \"" + DIGESTER_DTD_PATH + "\"");
        }
        parser.setDigesterRulesDTD(dtdURL.toString());
        parser.setTarget(digester);
        parser.setBasePath(basePath);
        rulesDigester.addRuleSet(parser);
        rulesDigester.push(parser);
        rulesLoader.loadRules();
    }

    /**
     * Worker clreplaced encapsulates loading mechanisms.
     * Private until some reason is found to make it public.
     */
    private abstract static clreplaced XMLRulesLoader {

        /**
         * Load rules now
         */
        public abstract void loadRules() throws XmlLoadException;
    }

    /**
     * Loads XMLRules from an URL
     */
    private clreplaced URLXMLRulesLoader extends XMLRulesLoader {

        private URL url;

        public URLXMLRulesLoader(URL url) {
            this.url = url;
        }

        @Override
        public void loadRules() throws XmlLoadException {
            try {
                rulesDigester.parse(url.openStream());
            } catch (Exception ex) {
                throw new XmlLoadException(ex);
            }
        }
    }

    /**
     * Loads XMLRules from an InputSource
     */
    private clreplaced InputSourceXMLRulesLoader extends XMLRulesLoader {

        private InputSource inputSource;

        public InputSourceXMLRulesLoader(InputSource inputSource) {
            this.inputSource = inputSource;
        }

        @Override
        public void loadRules() throws XmlLoadException {
            try {
                rulesDigester.parse(inputSource);
            } catch (Exception ex) {
                throw new XmlLoadException(ex);
            }
        }
    }
}

19 Source : FromXmlRuleSet.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Base constructor
 */
private void init(XMLRulesLoader rulesLoader, DigesterRuleParser parser, Digester rulesDigester) {
    this.rulesLoader = rulesLoader;
    this.parser = parser;
    this.rulesDigester = rulesDigester;
}

19 Source : FromXmlRuleSet.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Adds to the digester the set of Rule instances defined in the
 * XML file for this rule set.
 * @see org.apache.commons.digester.RuleSetBase
 */
@Override
public void addRuleInstances(org.apache.commons.digester.Digester digester) throws XmlLoadException {
    addRuleInstances(digester, null);
}

19 Source : DigesterRuleParser.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * This is a RuleSet that parses XML into Digester rules, and then
 * adds those rules to a 'target' Digester.
 *
 * @since 1.2
 */
public clreplaced DigesterRuleParser extends RuleSetBase {

    public static final String DIGESTER_PUBLIC_ID = "-//Jakarta Apache //DTD digester-rules XML V1.0//EN";

    /**
     * path to the DTD
     */
    private String digesterDtdUrl;

    /**
     * This is the digester to which we are adding the rules that we parse
     * from the Rules XML doreplacedent.
     */
    protected Digester targetDigester;

    /**
     * See {@link #setBasePath}.
     */
    protected String basePath = "";

    /**
     * A stack whose toString method returns a '/'-separated concatenation
     * of all the elements in the stack.
     */
    protected clreplaced PatternStack<E> extends Stack<E> {

        private static final long serialVersionUID = 1L;

        @Override
        public String toString() {
            StringBuffer str = new StringBuffer();
            for (int i = 0; i < size(); i++) {
                String elem = get(i).toString();
                if (elem.length() > 0) {
                    if (str.length() > 0) {
                        str.append('/');
                    }
                    str.append(elem);
                }
            }
            return str.toString();
        }
    }

    /**
     * A stack used to maintain the current pattern. The Rules XML doreplacedent
     * type allows nesting of patterns. If an element defines a matching
     * pattern, the resulting pattern is a concatenation of that pattern with
     * all the ancestor elements' patterns. Hence the need for a stack.
     */
    protected PatternStack<String> patternStack;

    /**
     * Used to detect circular includes
     */
    private Set<String> includedFiles = new HashSet<String>();

    /**
     * Constructs a DigesterRuleParser. This object will be inoperable
     * until the target digester is set, via <code>setTarget(Digester)</code>
     */
    public DigesterRuleParser() {
        patternStack = new PatternStack<String>();
    }

    /**
     * Constructs a rule set for converting XML digester rule descriptions
     * into Rule objects, and adding them to the given Digester
     * @param targetDigester the Digester to add the rules to
     */
    public DigesterRuleParser(Digester targetDigester) {
        this.targetDigester = targetDigester;
        patternStack = new PatternStack<String>();
    }

    /**
     * Constructs a rule set for parsing an XML digester rule file that
     * has been included within an outer XML digester rule file. In this
     * case, we must preplaced the pattern stack and the target digester
     * to the rule set, as well as the list of files that have already
     * been included, for cycle detection.
     * @param targetDigester the Digester to add the rules to
     * @param stack Stack containing the prefix pattern string to be prepended
     * to any pattern parsed by this rule set.
     */
    private DigesterRuleParser(Digester targetDigester, PatternStack<String> stack, Set<String> includedFiles) {
        this.targetDigester = targetDigester;
        patternStack = stack;
        this.includedFiles = includedFiles;
    }

    /**
     * Sets the digester into which to add the parsed rules
     * @param d the Digester to add the rules to
     */
    public void setTarget(Digester d) {
        targetDigester = d;
    }

    /**
     * Set a base pattern beneath which all the rules loaded by this
     * object will be registered. If this string is not empty, and does
     * not end in a "/", then one will be added.
     *
     * @since 1.6
     */
    public void setBasePath(String path) {
        if (path == null) {
            basePath = "";
        } else if ((path.length() > 0) && !path.endsWith("/")) {
            basePath = path + "/";
        } else {
            basePath = path;
        }
    }

    /**
     * Sets the location of the digester rules DTD. This is the DTD used
     * to validate the rules XML file.
     */
    public void setDigesterRulesDTD(String dtdURL) {
        digesterDtdUrl = dtdURL;
    }

    /**
     * Returns the location of the DTD used to validate the digester rules
     * XML doreplacedent.
     */
    protected String getDigesterRulesDTD() {
        // ClreplacedLoader clreplacedLoader = getClreplaced().getClreplacedLoader();
        // URL url = clreplacedLoader.getResource(DIGESTER_DTD_PATH);
        // return url.toString();
        return digesterDtdUrl;
    }

    /**
     * Adds a rule the the target digester. After a rule has been created by
     * parsing the XML, it is added to the digester by calling this method.
     * Typically, this method is called via reflection, when executing
     * a SetNextRule, from the Digester that is parsing the rules XML.
     * @param rule a Rule to add to the target digester.
     */
    public void add(Rule rule) {
        targetDigester.addRule(basePath + patternStack.toString(), rule);
    }

    /**
     * Add to the given digester the set of Rule instances used to parse an XML
     * doreplacedent defining Digester rules. When the digester parses an XML file,
     * it will add the resulting rules & patterns to the 'target digester'
     * that was preplaceded in this RuleSet's constructor.<P>
     * If you extend this clreplaced to support additional rules, your implementation
     * should of this method should call this implementation first: i.e.
     * <code>super.addRuleInstances(digester);</code>
     */
    @Override
    public void addRuleInstances(Digester digester) {
        final String ruleClreplacedName = Rule.clreplaced.getName();
        digester.register(DIGESTER_PUBLIC_ID, getDigesterRulesDTD());
        digester.addRule("*/pattern", new PatternRule("value"));
        digester.addRule("*/include", new IncludeRule());
        digester.addFactoryCreate("*/bean-property-setter-rule", new BeanPropertySetterRuleFactory());
        digester.addRule("*/bean-property-setter-rule", new PatternRule("pattern"));
        digester.addSetNext("*/bean-property-setter-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/call-method-rule", new CallMethodRuleFactory());
        digester.addRule("*/call-method-rule", new PatternRule("pattern"));
        digester.addSetNext("*/call-method-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/object-param-rule", new ObjectParamRuleFactory());
        digester.addRule("*/object-param-rule", new PatternRule("pattern"));
        digester.addSetNext("*/object-param-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/call-param-rule", new CallParamRuleFactory());
        digester.addRule("*/call-param-rule", new PatternRule("pattern"));
        digester.addSetNext("*/call-param-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/factory-create-rule", new FactoryCreateRuleFactory());
        digester.addRule("*/factory-create-rule", new PatternRule("pattern"));
        digester.addSetNext("*/factory-create-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/object-create-rule", new ObjectCreateRuleFactory());
        digester.addRule("*/object-create-rule", new PatternRule("pattern"));
        digester.addSetNext("*/object-create-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/node-create-rule", new NodeCreateRuleFactory());
        digester.addRule("*/node-create-rule", new PatternRule("pattern"));
        digester.addSetNext("*/node-create-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/set-properties-rule", new SetPropertiesRuleFactory());
        digester.addRule("*/set-properties-rule", new PatternRule("pattern"));
        digester.addSetNext("*/set-properties-rule", "add", ruleClreplacedName);
        digester.addRule("*/set-properties-rule/alias", new SetPropertiesAliasRule());
        digester.addFactoryCreate("*/set-property-rule", new SetPropertyRuleFactory());
        digester.addRule("*/set-property-rule", new PatternRule("pattern"));
        digester.addSetNext("*/set-property-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/set-nested-properties-rule", new SetNestedPropertiesRuleFactory());
        digester.addRule("*/set-nested-properties-rule", new PatternRule("pattern"));
        digester.addSetNext("*/set-nested-properties-rule", "add", ruleClreplacedName);
        digester.addRule("*/set-nested-properties-rule/alias", new SetNestedPropertiesAliasRule());
        digester.addFactoryCreate("*/set-top-rule", new SetTopRuleFactory());
        digester.addRule("*/set-top-rule", new PatternRule("pattern"));
        digester.addSetNext("*/set-top-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/set-next-rule", new SetNextRuleFactory());
        digester.addRule("*/set-next-rule", new PatternRule("pattern"));
        digester.addSetNext("*/set-next-rule", "add", ruleClreplacedName);
        digester.addFactoryCreate("*/set-root-rule", new SetRootRuleFactory());
        digester.addRule("*/set-root-rule", new PatternRule("pattern"));
        digester.addSetNext("*/set-root-rule", "add", ruleClreplacedName);
    }

    /**
     * A rule for extracting the pattern matching strings from the rules XML.
     * In the digester-rules doreplacedent type, a pattern can either be declared
     * in the 'value' attribute of a <pattern> element (in which case the pattern
     * applies to all rules elements contained within the <pattern> element),
     * or it can be declared in the optional 'pattern' attribute of a rule
     * element.
     */
    private clreplaced PatternRule extends Rule {

        private String attrName;

        private String pattern = null;

        /**
         * @param attrName The name of the attribute containing the pattern
         */
        public PatternRule(String attrName) {
            super();
            this.attrName = attrName;
        }

        /**
         * If a pattern is defined for the attribute, push it onto the
         * pattern stack.
         */
        @Override
        public void begin(Attributes attributes) {
            pattern = attributes.getValue(attrName);
            if (pattern != null) {
                patternStack.push(pattern);
            }
        }

        /**
         * If there was a pattern for this element, pop it off the pattern
         * stack.
         */
        @Override
        public void end() {
            if (pattern != null) {
                patternStack.pop();
            }
        }
    }

    /**
     * A rule for including one rules XML file within another. Included files
     * behave as if they are 'macro-expanded' within the includer. This means
     * that the values of the pattern stack are prefixed to every pattern
     * in the included rules. <p>This rule will detect 'circular' includes,
     * which would result in infinite recursion. It throws a
     * CircularIncludeException when a cycle is detected, which will terminate
     * the parse.
     */
    private clreplaced IncludeRule extends Rule {

        public IncludeRule() {
            super();
        }

        /**
         * To include a rules xml file, we instantiate another Digester, and
         * another DigesterRulesRuleSet. We preplaced the
         * pattern stack and the target Digester to the new rule set, and
         * tell the Digester to parse the file.
         */
        @Override
        public void begin(Attributes attributes) throws Exception {
            // The path attribute gives the URI to another digester rules xml file
            String fileName = attributes.getValue("path");
            if (fileName != null && fileName.length() > 0) {
                includeXMLRules(fileName);
            }
            // The clreplaced attribute gives the name of a clreplaced that implements
            // the DigesterRulesSource interface
            String clreplacedName = attributes.getValue("clreplaced");
            if (clreplacedName != null && clreplacedName.length() > 0) {
                includeProgrammaticRules(clreplacedName);
            }
        }

        /**
         * Creates another DigesterRuleParser, and uses it to extract the rules
         * out of the give XML file. The contents of the current pattern stack
         * will be prepended to all of the pattern strings parsed from the file.
         */
        private void includeXMLRules(String fileName) throws IOException, SAXException, CircularIncludeException {
            ClreplacedLoader cl = Thread.currentThread().getContextClreplacedLoader();
            if (cl == null) {
                cl = DigesterRuleParser.this.getClreplaced().getClreplacedLoader();
            }
            URL fileURL = cl.getResource(fileName);
            if (fileURL == null) {
                throw new FileNotFoundException("File \"" + fileName + "\" not found.");
            }
            fileName = fileURL.toExternalForm();
            if (includedFiles.add(fileName) == false) {
                // circular include detected
                throw new CircularIncludeException(fileName);
            }
            // parse the included xml file
            DigesterRuleParser includedSet = new DigesterRuleParser(targetDigester, patternStack, includedFiles);
            includedSet.setDigesterRulesDTD(getDigesterRulesDTD());
            Digester digester = new Digester();
            digester.addRuleSet(includedSet);
            digester.push(DigesterRuleParser.this);
            digester.parse(fileName);
            includedFiles.remove(fileName);
        }

        /**
         * Creates an instance of the indicated clreplaced. The clreplaced must implement
         * the DigesterRulesSource interface. Preplacedes the target digester to
         * that instance. The DigesterRulesSource instance is supposed to add
         * rules into the digester. The contents of the current pattern stack
         * will be automatically prepended to all of the pattern strings added
         * by the DigesterRulesSource instance.
         */
        private void includeProgrammaticRules(String clreplacedName) throws ClreplacedNotFoundException, ClreplacedCastException, InstantiationException, IllegalAccessException {
            Clreplaced<?> cls = Clreplaced.forName(clreplacedName);
            DigesterRulesSource rulesSource = (DigesterRulesSource) cls.newInstance();
            // wrap the digester's Rules object, to prepend pattern
            Rules digesterRules = targetDigester.getRules();
            Rules prefixWrapper = new RulesPrefixAdapter(patternStack.toString(), digesterRules);
            targetDigester.setRules(prefixWrapper);
            try {
                rulesSource.getRules(targetDigester);
            } finally {
                // Put the unwrapped rules back
                targetDigester.setRules(digesterRules);
            }
        }
    }

    /**
     * Wraps a Rules object. Delegates all the Rules interface methods
     * to the underlying Rules object. Overrides the add method to prepend
     * a prefix to the pattern string.
     */
    private clreplaced RulesPrefixAdapter implements Rules {

        private Rules delegate;

        private String prefix;

        /**
         * @param patternPrefix the pattern string to prepend to the pattern
         * preplaceded to the add method.
         * @param rules The wrapped Rules object. All of this clreplaced's methods
         * preplaced through to this object.
         */
        public RulesPrefixAdapter(String patternPrefix, Rules rules) {
            prefix = patternPrefix;
            delegate = rules;
        }

        /**
         * Register a new Rule instance matching a pattern which is constructed
         * by concatenating the pattern prefix with the given pattern.
         */
        public void add(String pattern, Rule rule) {
            StringBuffer buffer = new StringBuffer();
            buffer.append(prefix);
            if (!pattern.startsWith("/")) {
                buffer.append('/');
            }
            buffer.append(pattern);
            delegate.add(buffer.toString(), rule);
        }

        /**
         * This method preplacedes through to the underlying Rules object.
         */
        public void clear() {
            delegate.clear();
        }

        /**
         * This method preplacedes through to the underlying Rules object.
         */
        public Digester getDigester() {
            return delegate.getDigester();
        }

        /**
         * This method preplacedes through to the underlying Rules object.
         */
        public String getNamespaceURI() {
            return delegate.getNamespaceURI();
        }

        /**
         * @deprecated Call match(namespaceURI,pattern) instead.
         */
        @Deprecated
        public List<Rule> match(String pattern) {
            return delegate.match(pattern);
        }

        /**
         * This method preplacedes through to the underlying Rules object.
         */
        public List<Rule> match(String namespaceURI, String pattern) {
            return delegate.match(namespaceURI, pattern);
        }

        /**
         * This method preplacedes through to the underlying Rules object.
         */
        public List<Rule> rules() {
            return delegate.rules();
        }

        /**
         * This method preplacedes through to the underlying Rules object.
         */
        public void setDigester(Digester digester) {
            delegate.setDigester(digester);
        }

        /**
         * This method preplacedes through to the underlying Rules object.
         */
        public void setNamespaceURI(String namespaceURI) {
            delegate.setNamespaceURI(namespaceURI);
        }
    }

    // /////////////////////////////////////////////////////////////////////
    // Clreplacedes beyond this point are ObjectCreationFactory implementations,
    // used to create Rule objects and initialize them from SAX attributes.
    // /////////////////////////////////////////////////////////////////////
    /**
     * Factory for creating a BeanPropertySetterRule.
     */
    private clreplaced BeanPropertySetterRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) throws Exception {
            Rule beanPropertySetterRule = null;
            String propertyname = attributes.getValue("propertyname");
            if (propertyname == null) {
                // call the setter method corresponding to the element name.
                beanPropertySetterRule = new BeanPropertySetterRule();
            } else {
                beanPropertySetterRule = new BeanPropertySetterRule(propertyname);
            }
            return beanPropertySetterRule;
        }
    }

    /**
     * Factory for creating a CallMethodRule.
     */
    protected clreplaced CallMethodRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            Rule callMethodRule = null;
            String methodName = attributes.getValue("methodname");
            // Select which element is to be the target. Default to zero,
            // ie the top object on the stack.
            int targetOffset = 0;
            String targetOffsetStr = attributes.getValue("targetoffset");
            if (targetOffsetStr != null) {
                targetOffset = Integer.parseInt(targetOffsetStr);
            }
            if (attributes.getValue("paramcount") == null) {
                // call against empty method
                callMethodRule = new CallMethodRule(targetOffset, methodName);
            } else {
                int paramCount = Integer.parseInt(attributes.getValue("paramcount"));
                String paramTypesAttr = attributes.getValue("paramtypes");
                if (paramTypesAttr == null || paramTypesAttr.length() == 0) {
                    callMethodRule = new CallMethodRule(targetOffset, methodName, paramCount);
                } else {
                    String[] paramTypes = getParamTypes(paramTypesAttr);
                    callMethodRule = new CallMethodRule(targetOffset, methodName, paramCount, paramTypes);
                }
            }
            return callMethodRule;
        }

        /**
         * Process the comma separated list of paramTypes
         * into an array of String clreplaced names
         */
        private String[] getParamTypes(String paramTypes) {
            String[] paramTypesArray;
            if (paramTypes != null) {
                ArrayList<String> paramTypesList = new ArrayList<String>();
                StringTokenizer tokens = new StringTokenizer(paramTypes, " \t\n\r,");
                while (tokens.hasMoreTokens()) {
                    paramTypesList.add(tokens.nextToken());
                }
                paramTypesArray = paramTypesList.toArray(new String[0]);
            } else {
                paramTypesArray = new String[0];
            }
            return paramTypesArray;
        }
    }

    /**
     * Factory for creating a CallParamRule.
     */
    protected clreplaced CallParamRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            // create callparamrule
            int paramIndex = Integer.parseInt(attributes.getValue("paramnumber"));
            String attributeName = attributes.getValue("attrname");
            String fromStack = attributes.getValue("from-stack");
            String stackIndex = attributes.getValue("stack-index");
            Rule callParamRule = null;
            if (attributeName == null) {
                if (stackIndex != null) {
                    callParamRule = new CallParamRule(paramIndex, Integer.parseInt(stackIndex));
                } else if (fromStack != null) {
                    callParamRule = new CallParamRule(paramIndex, Boolean.valueOf(fromStack).booleanValue());
                } else {
                    callParamRule = new CallParamRule(paramIndex);
                }
            } else {
                if (fromStack == null) {
                    callParamRule = new CallParamRule(paramIndex, attributeName);
                } else {
                    // specifying both from-stack and attribute name is not allowed
                    throw new RuntimeException("Attributes from-stack and attrname cannot both be present.");
                }
            }
            return callParamRule;
        }
    }

    /**
     * Factory for creating a ObjectParamRule
     */
    protected clreplaced ObjectParamRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) throws Exception {
            // create callparamrule
            int paramIndex = Integer.parseInt(attributes.getValue("paramnumber"));
            String attributeName = attributes.getValue("attrname");
            String type = attributes.getValue("type");
            String value = attributes.getValue("value");
            Rule objectParamRule = null;
            // type name is requried
            if (type == null) {
                throw new RuntimeException("Attribute 'type' is required.");
            }
            // create object instance
            Object param = null;
            Clreplaced<?> clazz = Clreplaced.forName(type);
            if (value == null) {
                param = clazz.newInstance();
            } else {
                param = ConvertUtils.convert(value, clazz);
            }
            if (attributeName == null) {
                objectParamRule = new ObjectParamRule(paramIndex, param);
            } else {
                objectParamRule = new ObjectParamRule(paramIndex, attributeName, param);
            }
            return objectParamRule;
        }
    }

    /**
     * Factory for creating a NodeCreateRule
     */
    protected clreplaced NodeCreateRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) throws Exception {
            String nodeType = attributes.getValue("type");
            if (nodeType == null || "".equals(nodeType)) {
                // uses Node.ELEMENT_NODE
                return new NodeCreateRule();
            } else if ("element".equals(nodeType)) {
                return new NodeCreateRule(Node.ELEMENT_NODE);
            } else if ("fragment".equals(nodeType)) {
                return new NodeCreateRule(Node.DOreplacedENT_FRAGMENT_NODE);
            } else {
                throw new RuntimeException("Unrecognized node type: " + nodeType + ".  This attribute is optional or can have a value of element|fragment.");
            }
        }
    }

    /**
     * Factory for creating a FactoryCreateRule
     */
    protected clreplaced FactoryCreateRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            String clreplacedName = attributes.getValue("clreplacedname");
            String attrName = attributes.getValue("attrname");
            boolean ignoreExceptions = "true".equalsIgnoreCase(attributes.getValue("ignore-exceptions"));
            return (attrName == null || attrName.length() == 0) ? new FactoryCreateRule(clreplacedName, ignoreExceptions) : new FactoryCreateRule(clreplacedName, attrName, ignoreExceptions);
        }
    }

    /**
     * Factory for creating a ObjectCreateRule
     */
    protected clreplaced ObjectCreateRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            String clreplacedName = attributes.getValue("clreplacedname");
            String attrName = attributes.getValue("attrname");
            return (attrName == null || attrName.length() == 0) ? new ObjectCreateRule(clreplacedName) : new ObjectCreateRule(clreplacedName, attrName);
        }
    }

    /**
     * Factory for creating a SetPropertiesRule
     */
    protected clreplaced SetPropertiesRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            return new SetPropertiesRule();
        }
    }

    /**
     * Factory for creating a SetPropertyRule
     */
    protected clreplaced SetPropertyRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            String name = attributes.getValue("name");
            String value = attributes.getValue("value");
            return new SetPropertyRule(name, value);
        }
    }

    /**
     * Factory for creating a SetNestedPropertiesRule
     */
    protected clreplaced SetNestedPropertiesRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            boolean allowUnknownChildElements = "true".equalsIgnoreCase(attributes.getValue("allow-unknown-child-elements"));
            SetNestedPropertiesRule snpr = new SetNestedPropertiesRule();
            snpr.setAllowUnknownChildElements(allowUnknownChildElements);
            return snpr;
        }
    }

    /**
     * Factory for creating a SetTopRuleFactory
     */
    protected clreplaced SetTopRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            String methodName = attributes.getValue("methodname");
            String paramType = attributes.getValue("paramtype");
            return (paramType == null || paramType.length() == 0) ? new SetTopRule(methodName) : new SetTopRule(methodName, paramType);
        }
    }

    /**
     * Factory for creating a SetNextRuleFactory
     */
    protected clreplaced SetNextRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            String methodName = attributes.getValue("methodname");
            String paramType = attributes.getValue("paramtype");
            return (paramType == null || paramType.length() == 0) ? new SetNextRule(methodName) : new SetNextRule(methodName, paramType);
        }
    }

    /**
     * Factory for creating a SetRootRuleFactory
     */
    protected clreplaced SetRootRuleFactory extends AbstractObjectCreationFactory {

        @Override
        public Object createObject(Attributes attributes) {
            String methodName = attributes.getValue("methodname");
            String paramType = attributes.getValue("paramtype");
            return (paramType == null || paramType.length() == 0) ? new SetRootRule(methodName) : new SetRootRule(methodName, paramType);
        }
    }

    /**
     * A rule for adding a attribute-property alias to the custom alias mappings of
     * the containing SetPropertiesRule rule.
     */
    protected clreplaced SetPropertiesAliasRule extends Rule {

        /**
         * <p>Base constructor.</p>
         */
        public SetPropertiesAliasRule() {
            super();
        }

        /**
         * Add the alias to the SetPropertiesRule object created by the
         * enclosing <set-properties-rule> tag.
         */
        @Override
        public void begin(Attributes attributes) {
            String attrName = attributes.getValue("attr-name");
            String propName = attributes.getValue("prop-name");
            SetPropertiesRule rule = (SetPropertiesRule) digester.peek();
            rule.addAlias(attrName, propName);
        }
    }

    /**
     * A rule for adding a attribute-property alias to the custom alias mappings of
     * the containing SetNestedPropertiesRule rule.
     */
    protected clreplaced SetNestedPropertiesAliasRule extends Rule {

        /**
         * <p>Base constructor.</p>
         */
        public SetNestedPropertiesAliasRule() {
            super();
        }

        /**
         * Add the alias to the SetNestedPropertiesRule object created by the
         * enclosing <set-nested-properties-rule> tag.
         */
        @Override
        public void begin(Attributes attributes) {
            String attrName = attributes.getValue("attr-name");
            String propName = attributes.getValue("prop-name");
            SetNestedPropertiesRule rule = (SetNestedPropertiesRule) digester.peek();
            rule.addAlias(attrName, propName);
        }
    }
}

19 Source : DigesterRuleParser.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Sets the digester into which to add the parsed rules
 * @param d the Digester to add the rules to
 */
public void setTarget(Digester d) {
    targetDigester = d;
}

19 Source : PluginRules.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Set the Digester instance with which this Rules instance is replacedociated.
 *
 * @param digester The newly replacedociated Digester instance
 */
public void setDigester(Digester digester) {
    this.digester = digester;
    decoratedRules.setDigester(digester);
}

19 Source : LogUtils.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Get the Log object replacedociated with the specified Digester instance,
 * or a "no-op" logging object if the digester reference is null.
 * <p>
 * You should use this method instead of digester.getLogger() in
 * any situation where the digester might be null.
 */
static Log getLogger(Digester digester) {
    if (digester == null) {
        return new org.apache.commons.logging.impl.NoOpLog();
    }
    return digester.getLogger();
}

19 Source : DigesterLoader.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Creates a new digester which rules are defined by replacedyzing the digester
 * annotations in the target clreplaced.
 *
 * @param target the clreplaced has to be replacedyzed.
 * @return a new Digester instance.
 */
public Digester createDigester(final Clreplaced<?> target) {
    Digester digester = new Digester();
    digester.setClreplacedLoader(target.getClreplacedLoader());
    addRules(target, digester);
    return digester;
}

19 Source : GoogleChartsHandler.java
with GNU Lesser General Public License v3.0
from dynamicreports

/**
 * {@inheritDoc}
 */
@Override
public void configureDigester(Digester digester) {
    components.keySet().forEach(name -> {
        String mapPattern = "*/componentElement/googleCharts/" + name;
        digester.addObjectCreate(mapPattern, components.get(name));
    });
}

18 Source : JRXmlTemplateDigesterFactory.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected void configureDigester(JasperReportsContext jasperReportsContext, Digester digester) throws SAXException, ParserConfigurationException {
    digester.setNamespaceAware(true);
    digester.setRuleNamespaceURI(JRXmlConstants.JASPERTEMPLATE_NAMESPACE);
    boolean validating = JRPropertiesUtil.getInstance(jasperReportsContext).getBooleanProperty(JRReportSaxParserFactory.COMPILER_XML_VALIDATION);
    digester.setErrorHandler(this);
    digester.setValidating(validating);
    digester.setFeature("http://xml.org/sax/features/validation", validating);
    digester.addRuleSet(rules);
}

18 Source : JRBaseFactory.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@Override
public void setDigester(Digester digester) {
    this.digester = digester;
}

18 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

@SuppressWarnings("deprecation")
protected void addMapRules(Digester digester) {
    String mapPattern = "*/componentElement/map";
    digester.addFactoryCreate(mapPattern, MapXmlFactory.clreplaced);
    String lareplacedudeExpressionPattern = mapPattern + "/lareplacedudeExpression";
    digester.addFactoryCreate(lareplacedudeExpressionPattern, JRExpressionFactory.clreplaced.getName());
    digester.addCallMethod(lareplacedudeExpressionPattern, "setText", 0);
    digester.addSetNext(lareplacedudeExpressionPattern, "setLareplacedudeExpression", JRExpression.clreplaced.getName());
    String longitudeExpressionPattern = mapPattern + "/longitudeExpression";
    digester.addFactoryCreate(longitudeExpressionPattern, JRExpressionFactory.clreplaced.getName());
    digester.addCallMethod(longitudeExpressionPattern, "setText", 0);
    digester.addSetNext(longitudeExpressionPattern, "setLongitudeExpression", JRExpression.clreplaced.getName());
    String addressExpressionPattern = mapPattern + "/addressExpression";
    digester.addFactoryCreate(addressExpressionPattern, JRExpressionFactory.clreplaced.getName());
    digester.addCallMethod(addressExpressionPattern, "setText", 0);
    digester.addSetNext(addressExpressionPattern, "setAddressExpression", JRExpression.clreplaced.getName());
    String zoomExpressionPattern = mapPattern + "/zoomExpression";
    digester.addFactoryCreate(zoomExpressionPattern, JRExpressionFactory.clreplaced.getName());
    digester.addCallMethod(zoomExpressionPattern, "setText", 0);
    digester.addSetNext(zoomExpressionPattern, "setZoomExpression", JRExpression.clreplaced.getName());
    String languageExpressionPattern = mapPattern + "/languageExpression";
    digester.addFactoryCreate(languageExpressionPattern, JRExpressionFactory.clreplaced.getName());
    digester.addCallMethod(languageExpressionPattern, "setText", 0);
    digester.addSetNext(languageExpressionPattern, "setLanguageExpression", JRExpression.clreplaced.getName());
    String componentNamespace = digester.getRuleNamespaceURI();
    String jrNamespace = JRXmlConstants.JASPERREPORTS_NAMESPACE;
    String markerDatasetPattern = mapPattern + "/markerDataset";
    digester.addFactoryCreate(markerDatasetPattern, net.sf.jasperreports.components.map.MarkerDatasetXmlFactory.clreplaced.getName());
    digester.addSetNext(markerDatasetPattern, "setMarkerDataset", net.sf.jasperreports.components.map.MarkerDataset.clreplaced.getName());
    String markerPattern = markerDatasetPattern + "/marker";
    digester.addFactoryCreate(markerPattern, net.sf.jasperreports.components.map.MarkerXmlFactory.clreplaced.getName());
    digester.addSetNext(markerPattern, "addMarker", net.sf.jasperreports.components.map.Marker.clreplaced.getName());
    String markerPropertyPattern = markerPattern + "/markerProperty";
    digester.addFactoryCreate(markerPropertyPattern, net.sf.jasperreports.components.map.MarkerPropertyXmlFactory.clreplaced.getName());
    digester.addSetNext(markerPropertyPattern, "addMarkerProperty", net.sf.jasperreports.components.map.MarkerProperty.clreplaced.getName());
    digester.setRuleNamespaceURI(jrNamespace);
    String markerPropertyValueExpressionPattern = markerPropertyPattern + "/" + JRXmlConstants.ELEMENT_valueExpression;
    digester.addFactoryCreate(markerPropertyValueExpressionPattern, JRExpressionFactory.clreplaced.getName());
    digester.addCallMethod(markerPropertyValueExpressionPattern, "setText", 0);
    digester.addSetNext(markerPropertyValueExpressionPattern, "setValueExpression", JRExpression.clreplaced.getName());
    digester.setRuleNamespaceURI(componentNamespace);
    String markerDataPattern = mapPattern + "/markerData";
    digester.addFactoryCreate(markerDataPattern, ItemDataXmlFactory.clreplaced.getName());
    digester.addSetNext(markerDataPattern, "addMarkerData", ItemData.clreplaced.getName());
    addItemRules(digester, markerDataPattern + "/item", jrNamespace);
    digester.setRuleNamespaceURI(jrNamespace);
    digester.addFactoryCreate(markerDataPattern + "/dataset", ItemDatasetFactory.clreplaced.getName());
    digester.addSetNext(markerDataPattern + "/dataset", "setDataset", JRElementDataset.clreplaced.getName());
    digester.setRuleNamespaceURI(componentNamespace);
    String pathStylePattern = mapPattern + "/pathStyle";
    digester.addFactoryCreate(pathStylePattern, ItemDataXmlFactory.clreplaced.getName());
    digester.addSetNext(pathStylePattern, "addPathStyle", ItemData.clreplaced.getName());
    addItemRules(digester, pathStylePattern + "/item", jrNamespace);
    digester.setRuleNamespaceURI(jrNamespace);
    digester.addFactoryCreate(pathStylePattern + "/dataset", ItemDatasetFactory.clreplaced.getName());
    digester.addSetNext(pathStylePattern + "/dataset", "setDataset", JRElementDataset.clreplaced.getName());
    digester.setRuleNamespaceURI(componentNamespace);
    String pathDataPattern = mapPattern + "/pathData";
    digester.addFactoryCreate(pathDataPattern, ItemDataXmlFactory.clreplaced.getName());
    digester.addSetNext(pathDataPattern, "addPathData", ItemData.clreplaced.getName());
    addItemRules(digester, pathDataPattern + "/item", jrNamespace);
    digester.setRuleNamespaceURI(jrNamespace);
    digester.addFactoryCreate(pathDataPattern + "/dataset", ItemDatasetFactory.clreplaced.getName());
    digester.addSetNext(pathDataPattern + "/dataset", "setDataset", JRElementDataset.clreplaced.getName());
    digester.setRuleNamespaceURI(componentNamespace);
}

18 Source : ComponentsXmlDigesterConfigurer.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected <T> void addExpressionRules(Digester digester, String expressionPattern, Clreplaced<T> factoryClreplaced, String setterMethod, boolean jrNamespace) {
    String originalNamespace = digester.getRuleNamespaceURI();
    if (jrNamespace) {
        digester.setRuleNamespaceURI(JRXmlWriter.JASPERREPORTS_NAMESPACE.getNamespaceURI());
    }
    digester.addFactoryCreate(expressionPattern, factoryClreplaced);
    digester.addCallMethod(expressionPattern, "setText", 0);
    digester.addSetNext(expressionPattern, setterMethod, JRExpression.clreplaced.getName());
    if (jrNamespace) {
        digester.setRuleNamespaceURI(originalNamespace);
    }
}

18 Source : CVDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected static void addEvaluationPropertiesRules(Digester digester, String pattern) {
    digester.addSetProperties(pattern, // properties to be ignored by this rule
    new String[] { JRXmlConstants.ATTRIBUTE_evaluationTime, CVXmlFactory.ATTRIBUTE_onErrorType }, new String[0]);
    digester.addRule(pattern, new XmlConstantPropertyRule(JRXmlConstants.ATTRIBUTE_evaluationTime, "evaluationTimeValue", EvaluationTimeEnum.values()));
    digester.addRule(pattern, new XmlConstantPropertyRule(CVXmlFactory.ATTRIBUTE_onErrorType, OnErrorTypeEnum.values()));
}

18 Source : CVDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected static void addCVItemDataRules(Digester digester, String pattern, String namespace) {
    digester.addObjectCreate(pattern, StandardItemData.clreplaced);
    digester.addSetNext(pattern, "addItemData", StandardItemData.clreplaced.getName());
    String itemPattern = pattern + "/item";
    digester.addObjectCreate(itemPattern, StandardItem.clreplaced);
    digester.addSetNext(itemPattern, "addItem", Item.clreplaced.getName());
    addItemPropertieyRules(digester, itemPattern + "/itemProperty", namespace);
    digester.setRuleNamespaceURI(JRXmlWriter.JASPERREPORTS_NAMESPACE.getNamespaceURI());
    digester.addFactoryCreate(pattern + "/dataset", CVItemDatasetFactory.clreplaced.getName());
    digester.addSetNext(pattern + "/dataset", "setDataset", JRElementDataset.clreplaced.getName());
    digester.setRuleNamespaceURI(namespace);
}

18 Source : CVDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

protected static void addItemPropertieyRules(Digester digester, String itemPropertyPattern, String namespace) {
    digester.addFactoryCreate(itemPropertyPattern, CVItemPropertyXmlFactory.clreplaced);
    digester.addSetNext(itemPropertyPattern, "addItemProperty", ItemProperty.clreplaced.getName());
    addExpressionRules(digester, itemPropertyPattern + "/" + JRXmlConstants.ELEMENT_valueExpression, "setValueExpression", true);
}

18 Source : CVDigester.java
with GNU Lesser General Public License v3.0
from TIBCOSoftware

public static void addRules(Digester digester) {
    // String jrNamespace = JRXmlConstants.JASPERREPORTS_NAMESPACE;
    String namespace = digester.getRuleNamespaceURI();
    String mainComponentPattern = "*/componentElement/customvisualization";
    digester.addFactoryCreate(mainComponentPattern, CVXmlFactory.clreplaced.getName());
    addEvaluationPropertiesRules(digester, mainComponentPattern);
    addItemPropertieyRules(digester, mainComponentPattern + "/" + CVXmlFactory.ELEMENT_itemProperty, namespace);
    addCVItemDataRules(digester, mainComponentPattern + "/" + CVXmlFactory.ELEMENT_cvData, namespace);
}

18 Source : DigesterRuleParser.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Add to the given digester the set of Rule instances used to parse an XML
 * doreplacedent defining Digester rules. When the digester parses an XML file,
 * it will add the resulting rules & patterns to the 'target digester'
 * that was preplaceded in this RuleSet's constructor.<P>
 * If you extend this clreplaced to support additional rules, your implementation
 * should of this method should call this implementation first: i.e.
 * <code>super.addRuleInstances(digester);</code>
 */
@Override
public void addRuleInstances(Digester digester) {
    final String ruleClreplacedName = Rule.clreplaced.getName();
    digester.register(DIGESTER_PUBLIC_ID, getDigesterRulesDTD());
    digester.addRule("*/pattern", new PatternRule("value"));
    digester.addRule("*/include", new IncludeRule());
    digester.addFactoryCreate("*/bean-property-setter-rule", new BeanPropertySetterRuleFactory());
    digester.addRule("*/bean-property-setter-rule", new PatternRule("pattern"));
    digester.addSetNext("*/bean-property-setter-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/call-method-rule", new CallMethodRuleFactory());
    digester.addRule("*/call-method-rule", new PatternRule("pattern"));
    digester.addSetNext("*/call-method-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/object-param-rule", new ObjectParamRuleFactory());
    digester.addRule("*/object-param-rule", new PatternRule("pattern"));
    digester.addSetNext("*/object-param-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/call-param-rule", new CallParamRuleFactory());
    digester.addRule("*/call-param-rule", new PatternRule("pattern"));
    digester.addSetNext("*/call-param-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/factory-create-rule", new FactoryCreateRuleFactory());
    digester.addRule("*/factory-create-rule", new PatternRule("pattern"));
    digester.addSetNext("*/factory-create-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/object-create-rule", new ObjectCreateRuleFactory());
    digester.addRule("*/object-create-rule", new PatternRule("pattern"));
    digester.addSetNext("*/object-create-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/node-create-rule", new NodeCreateRuleFactory());
    digester.addRule("*/node-create-rule", new PatternRule("pattern"));
    digester.addSetNext("*/node-create-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/set-properties-rule", new SetPropertiesRuleFactory());
    digester.addRule("*/set-properties-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-properties-rule", "add", ruleClreplacedName);
    digester.addRule("*/set-properties-rule/alias", new SetPropertiesAliasRule());
    digester.addFactoryCreate("*/set-property-rule", new SetPropertyRuleFactory());
    digester.addRule("*/set-property-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-property-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/set-nested-properties-rule", new SetNestedPropertiesRuleFactory());
    digester.addRule("*/set-nested-properties-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-nested-properties-rule", "add", ruleClreplacedName);
    digester.addRule("*/set-nested-properties-rule/alias", new SetNestedPropertiesAliasRule());
    digester.addFactoryCreate("*/set-top-rule", new SetTopRuleFactory());
    digester.addRule("*/set-top-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-top-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/set-next-rule", new SetNextRuleFactory());
    digester.addRule("*/set-next-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-next-rule", "add", ruleClreplacedName);
    digester.addFactoryCreate("*/set-root-rule", new SetRootRuleFactory());
    digester.addRule("*/set-root-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-root-rule", "add", ruleClreplacedName);
}

18 Source : DigesterLoader.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Given the digester rules XML file, a clreplaced loader, and an input stream,
 * this method parses the input into Java objects. The clreplaced loader
 * is used by the digester to create the Java objects.
 * @param digesterRules URL to the XML doreplacedent defining the digester rules
 * @param clreplacedLoader the ClreplacedLoader to register with the digester
 * @param reader Reader over the XML file to parse into Java objects
 * @return an Object which is the root of the network of Java objects
 * created by digesting fileURL
 */
public static Object load(URL digesterRules, ClreplacedLoader clreplacedLoader, Reader reader) throws IOException, SAXException, DigesterLoadingException {
    Digester digester = createDigester(digesterRules);
    digester.setClreplacedLoader(clreplacedLoader);
    try {
        return digester.parse(reader);
    } catch (XmlLoadException ex) {
        // This is a runtime exception that can be thrown by
        // FromXmlRuleSet#addRuleInstances, which is called by the Digester
        // before it parses the file.
        throw new DigesterLoadingException(ex.getMessage(), ex);
    }
}

18 Source : DigesterLoader.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Given the digester rules XML file, a clreplaced loader, and an input stream,
 * this method parses the input into Java objects. The clreplaced loader
 * is used by the digester to create the Java objects.
 * @param digesterRules URL to the XML doreplacedent defining the digester rules
 * @param clreplacedLoader the ClreplacedLoader to register with the digester
 * @param input InputStream over the XML file to parse into Java objects
 * @return an Object which is the root of the network of Java objects
 * created by digesting fileURL
 */
public static Object load(URL digesterRules, ClreplacedLoader clreplacedLoader, InputStream input) throws IOException, SAXException, DigesterLoadingException {
    Digester digester = createDigester(digesterRules);
    digester.setClreplacedLoader(clreplacedLoader);
    try {
        return digester.parse(input);
    } catch (XmlLoadException ex) {
        // This is a runtime exception that can be thrown by
        // FromXmlRuleSet#addRuleInstances, which is called by the Digester
        // before it parses the file.
        throw new DigesterLoadingException(ex.getMessage(), ex);
    }
}

18 Source : FinderFromDfltResource.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * If there exists a resource file whose name is equal to the plugin
 * clreplaced name + the suffix specified in the constructor, then
 * load that file, run it through the xmlrules module and return an object
 * encapsulating those rules.
 * <p>
 * If there is no such resource file, then just return null.
 * <p>
 * The returned object (when non-null) will add the selected rules to
 * the digester whenever its addRules method is invoked.
 */
@Override
public RuleLoader findLoader(Digester d, Clreplaced<?> pluginClreplaced, Properties p) throws PluginException {
    String resourceName = pluginClreplaced.getName().replace('.', '/') + resourceSuffix;
    InputStream is = pluginClreplaced.getClreplacedLoader().getResourcereplacedtream(resourceName);
    if (is == null) {
        // ok, no such resource
        return null;
    }
    return FinderFromResource.loadRules(d, pluginClreplaced, is, resourceName);
}

18 Source : FinderFromDfltMethod.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * If there exists on the plugin clreplaced a method with name matching the
 * constructor's methodName value then locate the appropriate Method on
 * the plugin clreplaced and return an object encapsulating that info.
 * <p>
 * If there is no matching method then just return null.
 * <p>
 * The returned object (when non-null) will invoke the target method
 * on the plugin clreplaced whenever its addRules method is invoked. The
 * target method is expected to have the following prototype:
 * <code> public static void xxxxx(Digester d, String patternPrefix); </code>
 */
@Override
public RuleLoader findLoader(Digester d, Clreplaced<?> pluginClreplaced, Properties p) throws PluginException {
    Method rulesMethod = LoaderFromClreplaced.locateMethod(pluginClreplaced, methodName);
    if (rulesMethod == null) {
        return null;
    }
    return new LoaderFromClreplaced(pluginClreplaced, rulesMethod);
}

18 Source : FinderFromDfltClass.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * If there exists a clreplaced whose name is the plugin clreplaced name + the
 * suffix specified to the constructor, then load that clreplaced, locate
 * the appropriate rules-adding method on that clreplaced, and return an
 * object encapsulating that info.
 * <p>
 * If there is no such clreplaced, then just return null.
 * <p>
 * The returned object (when non-null) will invoke the target method
 * on the selected clreplaced whenever its addRules method is invoked. The
 * target method is expected to have the following prototype:
 * <code> public static void xxxxx(Digester d, String patternPrefix); </code>
 */
@Override
public RuleLoader findLoader(Digester digester, Clreplaced<?> pluginClreplaced, Properties p) throws PluginException {
    String rulesClreplacedName = pluginClreplaced.getName() + rulesClreplacedSuffix;
    Clreplaced<?> rulesClreplaced = null;
    try {
        rulesClreplaced = digester.getClreplacedLoader().loadClreplaced(rulesClreplacedName);
    } catch (ClreplacedNotFoundException cnfe) {
        // nope, no rule-info clreplaced in the clreplacedpath
        return null;
    }
    if (methodName == null) {
        methodName = DFLT_METHOD_NAME;
    }
    return new LoaderFromClreplaced(rulesClreplaced, methodName);
}

18 Source : PluginRules.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * A custom digester Rules manager which must be used as the Rules object
 * when using the plugins module functionality.
 * <p>
 * During parsing, a linked list of PluginCreateRule instances develop, and
 * this list also acts like a stack. The original instance that was set before
 * the Digester started parsing is always at the tail of the list, and the
 * Digester always holds a reference to the instance at the head of the list
 * in the rules member. Initially, this list/stack holds just one instance,
 * ie head and tail are the same object.
 * <p>
 * When the start of an xml element causes a PluginCreateRule to fire, a new
 * PluginRules instance is created and inserted at the head of the list (ie
 * pushed onto the stack of Rules objects). Digester.getRules() therefore
 * returns this new Rules object, and any custom rules replacedociated with that
 * plugin are added to that instance.
 * <p>
 * When the end of the xml element is encountered (and therefore the
 * PluginCreateRule end method fires), the stack of Rules objects is popped,
 * so that Digester.getRules returns the previous Rules object.
 *
 * @since 1.6
 */
public clreplaced PluginRules implements Rules {

    /**
     * The Digester instance with which this Rules instance is replacedociated.
     */
    protected Digester digester = null;

    /**
     * The (optional) object which generates new rules instances.
     */
    private RulesFactory rulesFactory;

    /**
     * The rules implementation that we are "enhancing" with plugins
     * functionality, as per the Decorator pattern.
     */
    private Rules decoratedRules;

    /**
     * Object which contains information about all known plugins.
     */
    private PluginManager pluginManager;

    /**
     * The path below which this rules object has responsibility.
     * For paths shorter than or equal the mountpoint, the parent's
     * match is called.
     */
    private String mountPoint = null;

    /**
     * The Rules object that holds rules applying "above" the mountpoint,
     * ie the next Rules object down in the stack.
     */
    private PluginRules parent = null;

    /**
     * A reference to the object that holds all data which should only
     * exist once per digester instance.
     */
    private PluginContext pluginContext = null;

    // ------------------------------------------------------------- Constructor
    /**
     * Constructor for top-level Rules objects. Exactly one of these must
     * be created and installed into the Digester instance as the Rules
     * object before parsing starts.
     */
    public PluginRules() {
        this(new RulesBase());
    }

    /**
     * Constructor for top-level Rules object which handles rule-matching
     * using the specified implementation.
     */
    public PluginRules(Rules decoratedRules) {
        this.decoratedRules = decoratedRules;
        pluginContext = new PluginContext();
        pluginManager = new PluginManager(pluginContext);
    }

    /**
     * Constructs a Rules instance which has a parent Rules object
     * (which is different from having a delegate rules object).
     * <p>
     * One of these is created each time a PluginCreateRule's begin method
     * fires, in order to manage the custom rules replacedociated with whatever
     * concrete plugin clreplaced the user has specified.
     *
     * @param digester is the object this rules will be replacedociated with.
     * @param mountPoint is the digester match path for the element
     * matching a PluginCreateRule which caused this "nested parsing scope"
     * to begin. This is expected to be equal to digester.getMatch().
     * @param parent must be non-null.
     * @param pluginClreplaced is the plugin clreplaced whose custom rules will be
     * loaded into this new PluginRules object.
     */
    PluginRules(Digester digester, String mountPoint, PluginRules parent, Clreplaced<?> pluginClreplaced) throws PluginException {
        // no need to set digester or decoratedRules.digester,
        // because when Digester.setRules is called, the setDigester
        // method on this object will be called.
        this.digester = digester;
        this.mountPoint = mountPoint;
        this.parent = parent;
        this.rulesFactory = parent.rulesFactory;
        if (rulesFactory == null) {
            decoratedRules = new RulesBase();
        } else {
            decoratedRules = rulesFactory.newRules(digester, pluginClreplaced);
        }
        pluginContext = parent.pluginContext;
        pluginManager = new PluginManager(parent.pluginManager);
    }

    // ------------------------------------------------------------- Properties
    /**
     * Return the parent Rules object.
     */
    public Rules getParent() {
        return parent;
    }

    /**
     * Return the Digester instance with which this instance is replacedociated.
     */
    public Digester getDigester() {
        return digester;
    }

    /**
     * Set the Digester instance with which this Rules instance is replacedociated.
     *
     * @param digester The newly replacedociated Digester instance
     */
    public void setDigester(Digester digester) {
        this.digester = digester;
        decoratedRules.setDigester(digester);
    }

    /**
     * Return the namespace URI that will be applied to all subsequently
     * added <code>Rule</code> objects.
     */
    public String getNamespaceURI() {
        return decoratedRules.getNamespaceURI();
    }

    /**
     * Set the namespace URI that will be applied to all subsequently
     * added <code>Rule</code> objects.
     *
     * @param namespaceURI Namespace URI that must match on all
     *  subsequently added rules, or <code>null</code> for matching
     *  regardless of the current namespace URI
     */
    public void setNamespaceURI(String namespaceURI) {
        decoratedRules.setNamespaceURI(namespaceURI);
    }

    /**
     * Return the object which "knows" about all declared plugins.
     *
     * @return The pluginManager value
     */
    public PluginManager getPluginManager() {
        return pluginManager;
    }

    /**
     * See {@link PluginContext#getRuleFinders}.
     */
    public List<RuleFinder> getRuleFinders() {
        return pluginContext.getRuleFinders();
    }

    /**
     * See {@link PluginContext#setRuleFinders}.
     */
    public void setRuleFinders(List<RuleFinder> ruleFinders) {
        pluginContext.setRuleFinders(ruleFinders);
    }

    /**
     * Return the rules factory object (or null if one has not been specified).
     */
    public RulesFactory getRulesFactory() {
        return rulesFactory;
    }

    /**
     * Set the object which is used to generate the new Rules instances created
     * to hold and process the rules replacedociated with each plugged-in clreplaced.
     */
    public void setRulesFactory(RulesFactory factory) {
        rulesFactory = factory;
    }

    // --------------------------------------------------------- Public Methods
    /**
     * This package-scope method is used by the PluginCreateRule clreplaced to
     * get direct access to the rules that were dynamically added by the
     * plugin. No other clreplaced should need access to this object.
     */
    Rules getDecoratedRules() {
        return decoratedRules;
    }

    /**
     * Return the list of rules registered with this object, in the order
     * they were registered with this object.
     * <p>
     * Note that Rule objects stored in parent Rules objects are not
     * returned by this method.
     *
     * @return list of all Rule objects known to this Rules instance.
     */
    public List<Rule> rules() {
        return decoratedRules.rules();
    }

    /**
     * Register a new Rule instance matching the specified pattern.
     *
     * @param pattern Nesting pattern to be matched for this Rule.
     * This parameter treats equally patterns that begin with and without
     * a leading slash ('/').
     * @param rule Rule instance to be registered
     */
    public void add(String pattern, Rule rule) {
        Log log = LogUtils.getLogger(digester);
        boolean debug = log.isDebugEnabled();
        if (debug) {
            log.debug("add entry" + ": mapping pattern [" + pattern + "]" + " to rule of type [" + rule.getClreplaced().getName() + "]");
        }
        // allow patterns with a leading slash character
        if (pattern.startsWith("/")) {
            pattern = pattern.substring(1);
        }
        if (mountPoint != null && !pattern.equals(mountPoint) && !pattern.startsWith(mountPoint + "/")) {
            // This can only occur if a plugin attempts to add a
            // rule with a pattern that doesn't start with the
            // prefix preplaceded to the addRules method. Plugins mustn't
            // add rules outside the scope of the tag they were specified
            // on, so refuse this.
            // alas, can't throw exception
            log.warn("An attempt was made to add a rule with a pattern that" + "is not at or below the mountpoint of the current" + " PluginRules object." + " Rule pattern: " + pattern + ", mountpoint: " + mountPoint + ", rule type: " + rule.getClreplaced().getName());
            return;
        }
        decoratedRules.add(pattern, rule);
        if (rule instanceof InitializableRule) {
            try {
                ((InitializableRule) rule).postRegisterInit(pattern);
            } catch (PluginConfigurationException e) {
                // Currently, Digester doesn't handle exceptions well
                // from the add method. The workaround is for the
                // initialisable rule to remember that its initialisation
                // failed, and to throw the exception when begin is
                // called for the first time.
                if (debug) {
                    log.debug("Rule initialisation failed", e);
                }
                // throw e; -- alas, can't do this
                return;
            }
        }
        if (debug) {
            log.debug("add exit" + ": mapped pattern [" + pattern + "]" + " to rule of type [" + rule.getClreplaced().getName() + "]");
        }
    }

    /**
     * Clear all rules.
     */
    public void clear() {
        decoratedRules.clear();
    }

    /**
     * Return a List of all registered Rule instances that match the specified
     * nesting pattern, or a zero-length List if there are no matches.  If more
     * than one Rule instance matches, they <strong>must</strong> be returned
     * in the order originally registered through the <code>add()</code>
     * method.
     *
     * @param path the path to the xml nodes to be matched.
     *
     * @deprecated Call match(namespaceURI,pattern) instead.
     */
    @Deprecated
    public List<Rule> match(String path) {
        return (match(null, path));
    }

    /**
     * Return a List of all registered Rule instances that match the specified
     * nodepath, or a zero-length List if there are no matches.  If more
     * than one Rule instance matches, they <strong>must</strong> be returned
     * in the order originally registered through the <code>add()</code>
     * method.
     * <p>
     * @param namespaceURI Namespace URI for which to select matching rules,
     *  or <code>null</code> to match regardless of namespace URI
     * @param path the path to the xml nodes to be matched.
     */
    public List<Rule> match(String namespaceURI, String path) {
        Log log = LogUtils.getLogger(digester);
        boolean debug = log.isDebugEnabled();
        if (debug) {
            log.debug("Matching path [" + path + "] on rules object " + this.toString());
        }
        List<Rule> matches;
        if ((mountPoint != null) && (path.length() <= mountPoint.length())) {
            if (debug) {
                log.debug("Path [" + path + "] delegated to parent.");
            }
            matches = parent.match(namespaceURI, path);
        // Note that in the case where path equals mountPoint,
        // we deliberately return only the rules from the parent,
        // even though this object may hold some rules matching
        // this same path. See PluginCreateRule's begin, body and end
        // methods for the reason.
        } else {
            log.debug("delegating to decorated rules.");
            matches = decoratedRules.match(namespaceURI, path);
        }
        return matches;
    }

    /**
     * See {@link PluginContext#setPluginClreplacedAttribute}.
     */
    public void setPluginClreplacedAttribute(String namespaceUri, String attrName) {
        pluginContext.setPluginClreplacedAttribute(namespaceUri, attrName);
    }

    /**
     * See {@link PluginContext#setPluginIdAttribute}.
     */
    public void setPluginIdAttribute(String namespaceUri, String attrName) {
        pluginContext.setPluginIdAttribute(namespaceUri, attrName);
    }

    /**
     * See {@link PluginContext#getPluginClreplacedAttrNs}.
     */
    public String getPluginClreplacedAttrNs() {
        return pluginContext.getPluginClreplacedAttrNs();
    }

    /**
     * See {@link PluginContext#getPluginClreplacedAttr}.
     */
    public String getPluginClreplacedAttr() {
        return pluginContext.getPluginClreplacedAttr();
    }

    /**
     * See {@link PluginContext#getPluginIdAttrNs}.
     */
    public String getPluginIdAttrNs() {
        return pluginContext.getPluginIdAttrNs();
    }

    /**
     * See {@link PluginContext#getPluginIdAttr}.
     */
    public String getPluginIdAttr() {
        return pluginContext.getPluginIdAttr();
    }
}

See More Examples