Java Code Examples for org.apache.commons.digester.Digester#addRule()

/**
 * {@inheritDoc}
 */
public void addRuleInstances(Digester digester) {
    String pattern;
    Rule rule;
    for (Entry<String, List<AnnotationRuleProvider<Annotation, AnnotatedElement, Rule>>> entry :
            this.rules.entrySet()) {
        pattern = entry.getKey();
        for (AnnotationRuleProvider<Annotation, AnnotatedElement, Rule> provider : entry.getValue()) {
            rule = provider.get();
            if (this.namespaceURI != null) {
                rule.setNamespaceURI(this.namespaceURI);
            }
            digester.addRule(pattern, rule);
        }
    }
}
 

private void parseURL(URL u) {
    Digester d = new Digester();
    d.setValidating(false);

    d.push(this);
    d.addObjectCreate("factory/template", HashMap.class);
    d.addRule("factory/template", new AttributeCopyRule());
    d.addSetNext("factory/template", "addFactoryTemplate");

    try {
        d.parse(u.openStream());
    }
    catch (Exception e) {
        throw new ManifestFactoryParseException("Unable to parse " +
                                                builder.getManifestFilename(), e);
    }
}
 

@SuppressWarnings("deprecation")
protected <T> void addBarcodeRules(Digester digester, 
		String barcodePattern, Class<T> barcodeComponentClass,
		String[] ignoredProperties)
{
	digester.addObjectCreate(barcodePattern, barcodeComponentClass);
	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.class.getName());
	digester.addCallMethod(codeExpressionPattern, "setText", 0);
	digester.addSetNext(codeExpressionPattern, "setCodeExpression", 
			JRExpression.class.getName());
}
 

protected void addListRules(Digester digester)
{
	String listPattern = "*/componentElement/list";
	digester.addObjectCreate(listPattern, StandardListComponent.class);
	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.class);
	digester.addSetProperties(listContentsPattern);
	digester.addSetNext(listContentsPattern, "setContents");
	// rule to set the context dataset name
	digester.addRule(listContentsPattern, new DatasetRunReportContextRule<>(ListComponent.class));
}
 

public static void addSortComponentRules(Digester digester)
{
	String componentNamespace = digester.getRuleNamespaceURI();
	
	String sortComponentPattern = "*/componentElement/sort";
	digester.addObjectCreate(sortComponentPattern, SortComponent.class.getName());
	
	digester.addSetProperties(sortComponentPattern, new String[] {
			SortComponent.PROPERTY_EVALUATION_TIME,
			}, 
			new String[0]);
	
	digester.addRule(sortComponentPattern, 
			new XmlConstantPropertyRule(
					SortComponent.PROPERTY_EVALUATION_TIME,
					EvaluationTimeEnum.values()));

	digester.addFactoryCreate(sortComponentPattern + "/symbol", SortComponentSymbolFactory.class.getName());
	
	digester.setRuleNamespaceURI(JRXmlConstants.JASPERREPORTS_NAMESPACE);

	digester.addFactoryCreate(sortComponentPattern + "/symbol/font", SortComponentSymbolFontFactory.class.getName());
	digester.addSetNext(sortComponentPattern + "/symbol/font", "setSymbolFont", JRFont.class.getName());

	digester.setRuleNamespaceURI(componentNamespace);
}
 

private void parseURL(URL u) {
    Digester d = new Digester();
    d.setValidating(false);

    d.push(this);
    d.addObjectCreate("factory/template", HashMap.class);
    d.addRule("factory/template", new AttributeCopyRule());
    d.addSetNext("factory/template", "addFactoryTemplate");

    try {
        d.parse(u.openStream());
    }
    catch (Exception e) {
        throw new ManifestFactoryParseException("Unable to parse " +
                                                builder.getManifestFilename(), e);
    }
}
 

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()));
}
 

protected static void addComponentRules(JasperReportsContext jasperReportsContext, Digester digester)
{
	digester.addFactoryCreate("*/componentElement", JRComponentElementFactory.class.getName());
	digester.addSetNext("*/componentElement", "addElement", JRDesignElement.class.getName());
	
	Collection<ComponentsBundle> components = ComponentsEnvironment.getInstance(jasperReportsContext).getBundles();
	for (Iterator<ComponentsBundle> it = components.iterator(); it.hasNext();)
	{
		ComponentsBundle componentsBundle = it.next();
		ComponentsXmlParser xmlParser = componentsBundle.getXmlParser();
		digester.setRuleNamespaceURI(xmlParser.getNamespace());
		
		XmlDigesterConfigurer configurer = xmlParser.getDigesterConfigurer();
		if (configurer != null)
		{
			configurer.configureDigester(digester);
		}
		
		digester.setRuleNamespaceURI(xmlParser.getNamespace());
		for (Iterator<String> namesIt = componentsBundle.getComponentNames().iterator(); 
				namesIt.hasNext();)
		{
			String componentName = namesIt.next();
			digester.addRule("*/componentElement/" + componentName, 
					JRComponentRule.newInstance());
		}
	}
	
	digester.setRuleNamespaceURI(JRXmlConstants.JASPERREPORTS_NAMESPACE);
}
 

protected static void addPartComponentRules(JasperReportsContext jasperReportsContext, Digester digester)
{
	digester.addFactoryCreate("*/part", JRPartFactory.class.getName());
	digester.addRule("*/part", new UuidPropertyRule("uuid", "UUID"));
	digester.addSetNext("*/part", "addPart", JRPart.class.getName());

	addExpressionRules(digester, "*/part/" + JRXmlConstants.ELEMENT_partNameExpression, "setPartNameExpression");

	Collection<PartComponentsBundle> components = PartComponentsEnvironment.getInstance(jasperReportsContext).getBundles();
	for (Iterator<PartComponentsBundle> it = components.iterator(); it.hasNext();)
	{
		PartComponentsBundle componentsBundle = it.next();
		ComponentsXmlParser xmlParser = componentsBundle.getXmlParser();
		digester.setRuleNamespaceURI(xmlParser.getNamespace());
		
		XmlDigesterConfigurer configurer = xmlParser.getDigesterConfigurer();
		if (configurer != null)
		{
			configurer.configureDigester(digester);
		}
		
		digester.setRuleNamespaceURI(xmlParser.getNamespace());
		for (Iterator<String> namesIt = componentsBundle.getComponentNames().iterator(); 
				namesIt.hasNext();)
		{
			String componentName = namesIt.next();
			digester.addRule("*/part/" + componentName, 
					JRPartComponentRule.newInstance());
		}
	}
	
	digester.setRuleNamespaceURI(JRXmlConstants.JASPERREPORTS_NAMESPACE);
}
 

private static void addDatasetRules(Digester digester)
{
	String subDatasetPattern = "jasperReport/" + JRXmlConstants.ELEMENT_subDataset;
	digester.addFactoryCreate(subDatasetPattern, JRDatasetFactory.class.getName());
	digester.addSetNext(subDatasetPattern, "addDataset", JRDesignDataset.class.getName());

	String datasetRunPattern = "*/" + JRXmlConstants.ELEMENT_datasetRun;
	digester.addFactoryCreate(datasetRunPattern, JRDatasetRunFactory.class.getName());
	digester.addSetNext(datasetRunPattern, "setDatasetRun", JRDatasetRun.class.getName());

	String datasetParamPattern = datasetRunPattern + "/" + JRXmlConstants.ELEMENT_datasetParameter;
	digester.addFactoryCreate(datasetParamPattern, JRDatasetRunParameterFactory.class.getName());
	digester.addSetNext(datasetParamPattern, "addParameter", JRDatasetParameter.class.getName());

	String datasetParamExprPattern = datasetParamPattern + "/" + JRXmlConstants.ELEMENT_datasetParameterExpression;
	digester.addFactoryCreate(datasetParamExprPattern, JRExpressionFactory.class.getName());
	digester.addSetNext(datasetParamExprPattern, "setExpression", JRExpression.class.getName());
	digester.addCallMethod(datasetParamExprPattern, "setText", 0);

	String returnValuePattern = datasetRunPattern + "/" + JRXmlConstants.ELEMENT_returnValue;
	digester.addObjectCreate(returnValuePattern, DesignReturnValue.class.getName());
	digester.addSetProperties(returnValuePattern, 
			new String[]{JRXmlConstants.ATTRIBUTE_incrementerFactoryClass, JRXmlConstants.ATTRIBUTE_calculation}, 
			new String[]{"incrementerFactoryClassName"});
	digester.addRule(returnValuePattern, new XmlConstantPropertyRule(
			JRXmlConstants.ATTRIBUTE_calculation, CalculationEnum.values()));
	digester.addSetNext(returnValuePattern, "addReturnValue");
}
 

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

private static void addFrameRules(Digester digester)
{
	String framePattern = "*/" + JRXmlConstants.ELEMENT_frame;
	digester.addFactoryCreate(framePattern, JRFrameFactory.class.getName());
	digester.addSetNext(framePattern, "addElement", JRDesignElement.class.getName());
	digester.addRule(framePattern, new XmlConstantPropertyRule(JRXmlConstants.ATTRIBUTE_borderSplitType, BorderSplitType.values()));
}
 

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

/**
 * 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 {
                final int length = "arg".length(); // skip the arg prefix
                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);

}
 

@SuppressWarnings("deprecation")
protected void addBarbecueRules(Digester digester)
{
	String barcodePattern = "*/componentElement/barbecue";
	digester.addObjectCreate(barcodePattern, StandardBarbecueComponent.class);
	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.class.getName());
	digester.addCallMethod(barcodeExpressionPattern, "setText", 0);
	digester.addSetNext(barcodeExpressionPattern, "setCodeExpression", 
			JRExpression.class.getName());

	String applicationIdentifierExpressionPattern = barcodePattern 
			+ "/applicationIdentifierExpression";
	digester.addFactoryCreate(applicationIdentifierExpressionPattern, 
			JRExpressionFactory.StringExpressionFactory.class.getName());
	digester.addCallMethod(applicationIdentifierExpressionPattern, "setText", 0);
	digester.addSetNext(applicationIdentifierExpressionPattern, 
			"setApplicationIdentifierExpression", 
			JRExpression.class.getName());
}
 

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

private static void addMultiAxisDataRules(Digester digester)
{
	String dataPattern = "*/" + JRXmlConstants.ELEMENT_multiAxisData;
	digester.addObjectCreate(dataPattern, DesignMultiAxisData.class);
	digester.addSetNext(dataPattern, "setMultiAxisData");// TODO lucianc move to containing element
	
	String datasetPattern = dataPattern + "/" + JRXmlConstants.ELEMENT_multiAxisDataset;
	digester.addObjectCreate(datasetPattern, DesignMultiAxisDataset.class);
	digester.addSetNext(datasetPattern, "setDataset");
	
	String dataAxisPattern = dataPattern + "/" + JRXmlConstants.ELEMENT_dataAxis;
	digester.addObjectCreate(dataAxisPattern, DesignDataAxis.class);
	digester.addRule(dataAxisPattern, new XmlConstantPropertyRule(JRXmlConstants.ATTRIBUTE_axis, Axis.values()));
	digester.addSetNext(dataAxisPattern, "addDataAxis");
	
	String axisLevelPattern = dataAxisPattern + "/" + JRXmlConstants.ELEMENT_axisLevel;
	digester.addObjectCreate(axisLevelPattern, DesignDataAxisLevel.class);
	digester.addSetProperties(axisLevelPattern);
	digester.addSetNext(axisLevelPattern, "addLevel");
	addExpressionRules(digester, axisLevelPattern + "/" + JRXmlConstants.ELEMENT_labelExpression, 
			"setLabelExpression");
	
	String bucketPattern = axisLevelPattern + "/" + JRXmlConstants.ELEMENT_axisLevelBucket;
	digester.addObjectCreate(bucketPattern, DesignDataLevelBucket.class);
	digester.addSetProperties(bucketPattern, 
			new String[]{JRXmlConstants.ATTRIBUTE_class, JRXmlConstants.ATTRIBUTE_order}, 
			new String[]{"valueClassName"});
	digester.addRule(bucketPattern, new XmlConstantPropertyRule(JRXmlConstants.ATTRIBUTE_order, BucketOrder.values()));
	digester.addSetNext(bucketPattern, "setBucket");
	
	addExpressionRules(digester, bucketPattern + "/" + JRCrosstabBucketFactory.ELEMENT_bucketExpression, "setExpression");
	addExpressionRules(digester, bucketPattern + "/" + JRXmlConstants.ELEMENT_MULTI_AXIS_BUCKET_LABEL_EXPRESSION, "setLabelExpression");
	addExpressionRules(digester, bucketPattern + "/" + JRCrosstabBucketFactory.ELEMENT_comparatorExpression, "setComparatorExpression");
	
	String bucketExpressionPattern = bucketPattern + "/" + JRXmlConstants.ELEMENT_bucketProperty;
	digester.addObjectCreate(bucketExpressionPattern, DesignDataLevelBucketProperty.class);
	digester.addSetProperties(bucketExpressionPattern);
	digester.addSetNext(bucketExpressionPattern, "addBucketProperty");		
	addExpressionRules(digester, bucketExpressionPattern, "setExpression");
	
	String measurePattern = dataPattern + "/" + JRXmlConstants.ELEMENT_multiAxisMeasure;
	digester.addObjectCreate(measurePattern, DesignDataMeasure.class);
	digester.addSetNext(measurePattern, "addMeasure");
	digester.addSetProperties(measurePattern, 
			new String[]{JRXmlConstants.ATTRIBUTE_class, JRXmlConstants.ATTRIBUTE_incrementerFactoryClass, 
					JRXmlConstants.ATTRIBUTE_calculation}, 
			new String[]{"valueClassName", "incrementerFactoryClassName"});
	digester.addRule(measurePattern, new XmlConstantPropertyRule(
			JRXmlConstants.ATTRIBUTE_calculation, CalculationEnum.values()));
	addExpressionRules(digester, measurePattern + "/" + JRXmlConstants.ELEMENT_labelExpression, 
			"setLabelExpression");
	addExpressionRules(digester, measurePattern + "/" + JRXmlConstants.ELEMENT_valueExpression, 
			"setValueExpression");
}
 

@Override
public void configureDigester(Digester digester)
{
	String componentNamespace = digester.getRuleNamespaceURI();
	String jrNamespace = JRXmlConstants.JASPERREPORTS_NAMESPACE;
	
	String xyChartPattern = "*/componentElement/XYChart";
	digester.addFactoryCreate(xyChartPattern, XYChartXmlFactory.class.getName());
	
	String xyDatasetPattern = xyChartPattern + "/XYDataset";
	digester.addFactoryCreate(xyDatasetPattern, XYDatasetXmlFactory.class.getName());
	digester.addSetNext(xyDatasetPattern, "setDataset", XYDataset.class.getName());

	digester.setRuleNamespaceURI(jrNamespace);

	String datasetPattern = xyDatasetPattern + "/dataset";
	digester.addFactoryCreate(datasetPattern, JRElementDatasetFactory.class.getName());

	String datasetIncrementWhenExpressionPath = datasetPattern + JRXmlConstants.ELEMENT_incrementWhenExpression;
	digester.addFactoryCreate(datasetIncrementWhenExpressionPath, JRExpressionFactory.class.getName());
	digester.addSetNext(datasetIncrementWhenExpressionPath, "setIncrementWhenExpression", JRExpression.class.getName());
	digester.addCallMethod(datasetIncrementWhenExpressionPath, "setText", 0);
	
	String datasetRunPattern = datasetPattern +"/" + JRXmlConstants.ELEMENT_datasetRun;
	digester.addFactoryCreate(datasetRunPattern, JRDatasetRunFactory.class.getName());
	digester.addSetNext(datasetRunPattern, "setDatasetRun", JRDatasetRun.class.getName());

	String datasetParamPattern = datasetRunPattern + "/" + JRXmlConstants.ELEMENT_datasetParameter;
	digester.addFactoryCreate(datasetParamPattern, JRDatasetRunParameterFactory.class.getName());
	digester.addSetNext(datasetParamPattern, "addParameter", JRDatasetParameter.class.getName());

	String datasetParamExprPattern = datasetParamPattern + "/" + JRXmlConstants.ELEMENT_datasetParameterExpression;
	digester.addFactoryCreate(datasetParamExprPattern, JRExpressionFactory.class.getName());
	digester.addSetNext(datasetParamExprPattern, "setExpression", JRExpression.class.getName());
	digester.addCallMethod(datasetParamExprPattern, "setText", 0);

	String returnValuePattern = datasetRunPattern + "/" + JRXmlConstants.ELEMENT_returnValue;
	digester.addObjectCreate(returnValuePattern, DesignReturnValue.class.getName());
	digester.addSetProperties(returnValuePattern, 
			new String[]{JRXmlConstants.ATTRIBUTE_incrementerFactoryClass, JRXmlConstants.ATTRIBUTE_calculation}, 
			new String[]{"incrementerFactoryClassName"});
	digester.addRule(returnValuePattern, new XmlConstantPropertyRule(
			JRXmlConstants.ATTRIBUTE_calculation, CalculationEnum.values()));
	digester.addSetNext(returnValuePattern, "addReturnValue");
	
	digester.setRuleNamespaceURI(componentNamespace);
	String seriesPattern = xyDatasetPattern + "/XYSeries";
	digester.addFactoryCreate(seriesPattern, XYSeriesFactory.class.getName());
	digester.addSetNext(seriesPattern, "addXYSeries", DesignXYSeries.class.getName());

	digester.setRuleNamespaceURI(jrNamespace);
	digester.addFactoryCreate(seriesPattern + "/seriesExpression", JRExpressionFactory.class.getName());
	digester.addSetNext(seriesPattern + "/seriesExpression", "setSeriesExpression", JRDesignExpression.class.getName());
	digester.addCallMethod(seriesPattern + "/seriesExpression", "setText", 0);
	
	digester.addFactoryCreate(seriesPattern + "/xValueExpression", JRExpressionFactory.class.getName());
	digester.addSetNext(seriesPattern + "/xValueExpression", "setXValueExpression", JRDesignExpression.class.getName());
	digester.addCallMethod(seriesPattern + "/xValueExpression", "setText", 0);
	
	digester.addFactoryCreate(seriesPattern + "/yValueExpression", JRExpressionFactory.class.getName());
	digester.addSetNext(seriesPattern + "/yValueExpression", "setYValueExpression", JRDesignExpression.class.getName());
	digester.addCallMethod(seriesPattern + "/yValueExpression", "setText", 0);

	digester.setRuleNamespaceURI(componentNamespace);
	
	digester.addFactoryCreate(seriesPattern + "/colorExpression", JRExpressionFactory.class.getName());
	digester.addSetNext(seriesPattern + "/colorExpression", "setColorExpression", JRDesignExpression.class.getName());
	digester.addCallMethod(seriesPattern + "/colorExpression", "setText", 0);
	
	String chartTitleExpressionPattern = xyChartPattern + "/chartTitleExpression";
	digester.addFactoryCreate(chartTitleExpressionPattern, JRExpressionFactory.class.getName());
	digester.addCallMethod(chartTitleExpressionPattern, "setText", 0);
	digester.addSetNext(chartTitleExpressionPattern, "setChartTitleExpression", JRExpression.class.getName());
	
	String xAxisTitleExpressionPattern = xyChartPattern + "/xAxisTitleExpression";
	digester.addFactoryCreate(xAxisTitleExpressionPattern, JRExpressionFactory.class.getName());
	digester.addCallMethod(xAxisTitleExpressionPattern, "setText", 0);
	digester.addSetNext(xAxisTitleExpressionPattern, "setXAxisTitleExpression", JRExpression.class.getName());
	
	String yAxisTitleExpressionPattern = xyChartPattern + "/yAxisTitleExpression";
	digester.addFactoryCreate(yAxisTitleExpressionPattern, JRExpressionFactory.class.getName());
	digester.addCallMethod(yAxisTitleExpressionPattern, "setText", 0);
	digester.addSetNext(yAxisTitleExpressionPattern, "setYAxisTitleExpression", JRExpression.class.getName());
	
}
 

/**
 * Add to the given digester the set of Rule instances used to parse an XML
 * document defining Digester rules. When the digester parses an XML file,
 * it will add the resulting rules & patterns to the 'target digester'
 * that was passed in this RuleSet's constructor.<P>
 * If you extend this class 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 ruleClassName = Rule.class.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", ruleClassName);
    
    digester.addFactoryCreate("*/call-method-rule", new CallMethodRuleFactory());
    digester.addRule("*/call-method-rule", new PatternRule("pattern"));
    digester.addSetNext("*/call-method-rule", "add", ruleClassName);

    digester.addFactoryCreate("*/object-param-rule", new ObjectParamRuleFactory());
    digester.addRule("*/object-param-rule", new PatternRule("pattern"));
    digester.addSetNext("*/object-param-rule", "add", ruleClassName);
    
    digester.addFactoryCreate("*/call-param-rule", new CallParamRuleFactory());
    digester.addRule("*/call-param-rule", new PatternRule("pattern"));
    digester.addSetNext("*/call-param-rule", "add", ruleClassName);
    
    digester.addFactoryCreate("*/factory-create-rule", new FactoryCreateRuleFactory());
    digester.addRule("*/factory-create-rule", new PatternRule("pattern"));
    digester.addSetNext("*/factory-create-rule", "add", ruleClassName);
    
    digester.addFactoryCreate("*/object-create-rule", new ObjectCreateRuleFactory());
    digester.addRule("*/object-create-rule", new PatternRule("pattern"));
    digester.addSetNext("*/object-create-rule", "add", ruleClassName);
    
    digester.addFactoryCreate("*/node-create-rule", new NodeCreateRuleFactory());
    digester.addRule("*/node-create-rule", new PatternRule("pattern"));
    digester.addSetNext("*/node-create-rule", "add", ruleClassName);
    
    digester.addFactoryCreate("*/set-properties-rule", new SetPropertiesRuleFactory());
    digester.addRule("*/set-properties-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-properties-rule", "add", ruleClassName);
    
    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", ruleClassName);
    
    digester.addFactoryCreate("*/set-nested-properties-rule", new SetNestedPropertiesRuleFactory());
    digester.addRule("*/set-nested-properties-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-nested-properties-rule", "add", ruleClassName);
    
    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", ruleClassName);
    
    digester.addFactoryCreate("*/set-next-rule", new SetNextRuleFactory());
    digester.addRule("*/set-next-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-next-rule", "add", ruleClassName);
    digester.addFactoryCreate("*/set-root-rule", new SetRootRuleFactory());
    digester.addRule("*/set-root-rule", new PatternRule("pattern"));
    digester.addSetNext("*/set-root-rule", "add", ruleClassName);
}
 

public void setDigesterRules(Digester d) {
	Rule attributeChecker=new AttributeCheckingRule();

	d.addFactoryCreate("*/monitoring",new CreationFactory());
	d.addSetProperties("*/monitoring");
	d.addSetTop("*/monitoring","register");
	d.addRule("*/monitoring", attributeChecker);

	d.addRule("*/monitoring/destinations",new DestinationCleanup());

	d.addObjectCreate("*/destination","className",IMonitorAdapter.class);
	d.addSetProperties("*/destination");
	d.addSetTop("*/destination","register");
	d.addRule("*/destination", attributeChecker);

	d.addObjectCreate("*/destination/sender","className",ISender.class);
	d.addSetProperties("*/destination/sender");
	d.addSetNext("*/destination/sender","setSender");
	d.addRule("*/destination/sender", attributeChecker);

	d.addObjectCreate("*/monitor",Monitor.class);
	d.addSetProperties("*/monitor");
	d.addSetTop("*/monitor","register");
	d.addRule("*/monitor", attributeChecker);

	d.addObjectCreate("*/alarm",Trigger.class);
	d.addSetProperties("*/alarm");
	d.addSetNext("*/alarm","registerAlarm");
	d.addRule("*/alarm", attributeChecker);

	d.addCallMethod("*/alarm/events/event", "addEventCode", 0);


	d.addObjectCreate("*/clearing",Trigger.class);
	d.addSetProperties("*/clearing");
	d.addSetNext("*/clearing","registerClearing");
	d.addRule("*/clearing", attributeChecker);

	d.addCallMethod("*/clearing/events/event", "addEventCode", 0);

	d.addObjectCreate("*/trigger",Trigger.class);
	d.addSetProperties("*/trigger");
	d.addSetNext("*/trigger","registerTrigger");
	d.addRule("*/trigger", attributeChecker);

	d.addCallMethod("*/trigger/events/event", "addEventCode", 0);

	d.addObjectCreate("*/adapterfilter",AdapterFilter.class);
	d.addSetProperties("*/adapterfilter");
	d.addSetNext("*/adapterfilter","registerAdapterFilter");
	d.addRule("*/adapterfilter", attributeChecker);

	d.addSetNext("*/adapterfilter/sources","setFilteringToLowerLevelObjects");
	d.addCallMethod("*/adapterfilter/sources/source", "registerSubOject", 0);

}