org.apache.commons.digester.Digester Java Examples

private static void configureDigester(Digester digester) {
    digester.setValidating(false);

    digester.addObjectCreate("params", ClientCertificate.class);
    digester.addObjectCreate("*/param/value/struct/member/", Member.class);
    digester.addCallMethod("*/param/value/struct/member/name",
            "setName", 0);
    digester.addCallMethod("*/param/value/struct/member/value/string",
            "addValue", 0);
    digester.addObjectCreate("*/param/value/struct/member/value/array",
            ArrayList.class);
    digester.addCallMethod(
            "*/param/value/struct/member/value/array/data/value/string",
            "add", 0);
    digester.addSetNext("*/param/value/struct/member/value/array",
            "setValues");
    digester.addSetNext("*/param/value/struct/member", "addMember");
}
 

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

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

@SuppressWarnings("rawtypes")
public ExtractChangeLogSet parse(AbstractBuild build, InputStream changeLogStream) throws IOException, SAXException {

    ArrayList<ExtractChangeLogEntry> changeLog = new ArrayList<ExtractChangeLogEntry>();

    Digester digester = new Digester();
    digester.setClassLoader(ExtractChangeLogSet.class.getClassLoader());
    digester.push(changeLog);
    digester.addObjectCreate("*/extractChanges/entry", ExtractChangeLogEntry.class);

    digester.addBeanPropertySetter("*/extractChanges/entry/zipFile");

    digester.addObjectCreate("*/extractChanges/entry/file",
            FileInZip.class);
    digester.addBeanPropertySetter("*/extractChanges/entry/file/fileName");
    digester.addSetNext("*/extractChanges/entry/file", "addFile");
    digester.addSetNext("*/extractChanges/entry", "add");

    digester.parse(changeLogStream);

    return new ExtractChangeLogSet(build, changeLog);
}
 

/**
 * {@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);
        }
    }
}
 

/**
 * 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
 * class, 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 = getClass().getClassLoader().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();
}
 

protected static void addExpressionRules(
	Digester digester,
	String expressionPattern,
	String setterMethod,
	boolean jrNamespace
	)
{
	String originalNamespace = digester.getRuleNamespaceURI();
	if (jrNamespace)
	{
		digester.setRuleNamespaceURI(JRXmlWriter.JASPERREPORTS_NAMESPACE.getNamespaceURI());
	}

	digester.addFactoryCreate(expressionPattern, JRExpressionFactory.class);
	digester.addCallMethod(expressionPattern, "setText", 0);
	digester.addSetNext(expressionPattern, setterMethod, JRExpression.class.getName());

	if (jrNamespace)
	{
		digester.setRuleNamespaceURI(originalNamespace);
	}
}
 

/**
 * Attempt to load custom rules for the target class at the specified
 * pattern.
 * <p>
 * On return, any custom rules associated with the plugin class have
 * been loaded into the Rules object currently associated with the
 * specified digester object.
 */
 
public void configure(Digester digester, String pattern)
                      throws PluginException {
    Log log = digester.getLogger();
    boolean debug = log.isDebugEnabled();
    if (debug) {
        log.debug("configure being called!");
    }
    
    if (!initialized) {
        throw new PluginAssertionFailure("Not initialized.");
    }

    if (ruleLoader != null) {
        ruleLoader.addRules(digester, pattern);
    }
}
 

public static Digester configurePrefsDigester(Digester digester) {        
    // prefs root
    digester.addObjectCreate("prefs", PrefsData.class );
    digester.addSetProperties("prefs" );
    digester.addBeanPropertySetter("prefs/listToolEventsOnlyAvailableInSite", "setListToolEventsOnlyAvailableInSite" );
    digester.addBeanPropertySetter("prefs/showOwnStatisticsToStudents", "setShowOwnStatisticsToStudents" );
    digester.addBeanPropertySetter("prefs/chartIn3D", "setChartIn3D" );
    digester.addBeanPropertySetter("prefs/chartTransparency", "setChartTransparency" );
    digester.addBeanPropertySetter("prefs/itemLabelsVisible", "setItemLabelsVisible" );
    digester.addBeanPropertySetter("prefs/useAllTools", "setUseAllTools" );
    
    // toolEventsDef
    digester = configureToolEventsDefDigester("prefs/", digester);
    digester.addSetNext("prefs/toolEventsDef", "setToolEventsDef" );
    
    
    return digester;
}
 

public static Digester configureToolEventsDefDigester(String prefix, Digester digester) {        
    // root
    digester.addObjectCreate(prefix + "toolEventsDef", ArrayList.class );

    // tool tag
    ToolFactoryImpl toolFactory = new ToolFactoryImpl();
    digester.addFactoryCreate(prefix + "toolEventsDef/tool", toolFactory);
    digester.addBeanPropertySetter(prefix + "toolEventsDef/tool/toolId", "toolId" );
    digester.addBeanPropertySetter(prefix + "toolEventsDef/tool/additionalToolIds", "additionalToolIdsStr" );
    digester.addBeanPropertySetter(prefix + "toolEventsDef/tool/selected", "selected" );
    digester.addSetNext(prefix + "toolEventsDef/tool", "add" );

    // event tag
    EventFactoryImpl eventFactoryImpl = new EventFactoryImpl();
    digester.addFactoryCreate(prefix + "toolEventsDef/tool/event", eventFactoryImpl);
    digester.addBeanPropertySetter(prefix + "toolEventsDef/tool/event/eventId", "eventId" );
    digester.addBeanPropertySetter(prefix + "toolEventsDef/tool/event/selected", "selected" );
    digester.addBeanPropertySetter(prefix + "toolEventsDef/tool/event/anonymous", "anonymous" );
    digester.addSetNext(prefix + "toolEventsDef/tool/event", "addEvent" );
    
    return digester;
}
 

protected void addItemRules(Digester digester, String itemPattern, String namespace)
{
	digester.addFactoryCreate(itemPattern, ItemXmlFactory.class.getName());
	digester.addSetNext(itemPattern, "addItem", Item.class.getName());

	String locationItemPropertyPattern = itemPattern + "/itemProperty";
	digester.addFactoryCreate(locationItemPropertyPattern, ItemPropertyXmlFactory.class.getName());
	digester.addSetNext(locationItemPropertyPattern, "addItemProperty", ItemProperty.class.getName());

	digester.setRuleNamespaceURI(namespace);
	
	String locationItemPropertyValueExpressionPattern = locationItemPropertyPattern + "/" + JRXmlConstants.ELEMENT_valueExpression;
	digester.addFactoryCreate(locationItemPropertyValueExpressionPattern, JRExpressionFactory.class.getName());
	digester.addCallMethod(locationItemPropertyValueExpressionPattern, "setText", 0);
	digester.addSetNext(locationItemPropertyValueExpressionPattern, "setValueExpression", JRExpression.class.getName());
}
 

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

public static List<ToolInfo> parseToolEventsDefinition(InputStream input) throws Exception{
	Digester digester = new Digester();
    digester.setValidating(false);
    
    digester = configureToolEventsDefDigester("", digester);

    // eventParserTip tag
    EventParserTipFactoryImpl eventParserTipFactoryImpl = new EventParserTipFactoryImpl();
    digester.addFactoryCreate("toolEventsDef/tool/eventParserTip", eventParserTipFactoryImpl);
    digester.addSetNestedProperties("toolEventsDef/tool/eventParserTip");
    digester.addSetNext("toolEventsDef/tool/eventParserTip", "addEventParserTip" );
    
    return (List<ToolInfo>) digester.parse( input );
}
 

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

@SuppressWarnings("deprecation")
protected void setHtmlComponentRules(Digester digester)
{
	String htmlComponentPattern = "*/componentElement/html";
	digester.addObjectCreate(htmlComponentPattern, HtmlComponent.class.getName());
	
	digester.addSetProperties(htmlComponentPattern, new String[] {
			HtmlComponent.PROPERTY_SCALE_TYPE,
			HtmlComponent.PROPERTY_HORIZONTAL_ALIGN,
			HtmlComponent.PROPERTY_VERTICAL_ALIGN,
			HtmlComponent.PROPERTY_EVALUATION_TIME }, 
			new String[0]);
			
	digester.addRule(htmlComponentPattern, 
			new XmlConstantPropertyRule(
					HtmlComponent.PROPERTY_SCALE_TYPE,
					ScaleImageEnum.values()));
	digester.addRule(htmlComponentPattern, 
			new XmlConstantPropertyRule(
					HtmlComponent.PROPERTY_HORIZONTAL_ALIGN,
					"horizontalImageAlign",
					HorizontalImageAlignEnum.values()));
	digester.addRule(htmlComponentPattern, 
			new XmlConstantPropertyRule(
					HtmlComponent.PROPERTY_VERTICAL_ALIGN,
					"verticalImageAlign",
					VerticalImageAlignEnum.values()));
	digester.addRule(htmlComponentPattern, 
			new XmlConstantPropertyRule(
					HtmlComponent.PROPERTY_EVALUATION_TIME,
					EvaluationTimeEnum.values()));

	String htmlContentPattern = htmlComponentPattern + "/htmlContentExpression";
	digester.addFactoryCreate(htmlContentPattern, JRExpressionFactory.StringExpressionFactory.class.getName());
	digester.addCallMethod(htmlContentPattern, "setText", 0);
	digester.addSetNext(htmlContentPattern, "setHtmlContentExpression", JRExpression.class.getName());
}
 

protected static void addItemPropertieyRules(Digester digester, String itemPropertyPattern, String namespace)
{
	digester.addFactoryCreate(itemPropertyPattern, CVItemPropertyXmlFactory.class);
	digester.addSetNext(itemPropertyPattern, "addItemProperty", ItemProperty.class.getName());

	addExpressionRules(digester, itemPropertyPattern + "/" + JRXmlConstants.ELEMENT_valueExpression,
			"setValueExpression", true);
}
 

/**
 * Create a ValidatorResources object from several URL.
 *
 * @param urls An array of URL to several validation.xml
 * configuration files that will be read in order and merged into this object.
 * @throws SAXException if the validation XML files are not valid or well
 * formed.
 * @throws IOException if an I/O error occurs processing the XML files
 * @since Validator 1.3.1
 */
public ValidatorResources(URL[] urls)
        throws IOException, SAXException {

    super();

    Digester digester = initDigester();
    for (int i = 0; i < urls.length; i++) {
        digester.push(this);
        digester.parse(urls[i]);
    }

    this.process();
}
 

/**
 * @return fully-initialized Digester used to process entry XML files
 */
private Digester buildDigester(String schemaLocation, String digestorRulesFileName) {
    Digester digester = new Digester();
    digester.setNamespaceAware(false);
    digester.setValidating(true);
    digester.setErrorHandler(new XmlErrorHandler());
    digester.setSchema(schemaLocation);

    Rules rules = loadRules(digestorRulesFileName);

    digester.setRules(rules);

    return digester;
}
 

/**
 * @return Rules loaded from the appropriate XML file
 */
private Rules loadRules(String digestorRulesFileName) {
    // locate Digester rules
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    URL rulesUrl = classLoader.getResource(digestorRulesFileName);
    if (rulesUrl == null) {
        throw new RuntimeException("unable to locate digester rules file " + digestorRulesFileName);
    }

    // create and init digester
    Digester digester = DigesterLoader.createDigester(rulesUrl);

    return digester.getRules();
}
 

/**
 * Given a plugin class and some associated properties, scan the
 * list of known RuleFinder instances until one detects a source of
 * custom rules for this plugin (aka a RuleLoader).
 * <p>
 * If no source of custom rules can be found, null is returned.
 */
public RuleLoader findLoader(Digester digester, String id, 
                    Class<?> pluginClass, Properties props) 
                    throws PluginException {    

    // iterate over the list of RuleFinders, trying each one 
    // until one of them locates a source of dynamic rules given
    // this specific plugin class and the associated declaration 
    // properties.
    Log log = LogUtils.getLogger(digester);
    boolean debug = log.isDebugEnabled();
    log.debug("scanning ruleFinders to locate loader..");
    
    List<RuleFinder> ruleFinders = pluginContext.getRuleFinders();
    RuleLoader ruleLoader = null;
    try {
        for(Iterator<RuleFinder> i = ruleFinders.iterator(); 
            i.hasNext() && ruleLoader == null; ) {
                
            RuleFinder finder = i.next();
            if (debug) {
                log.debug("checking finder of type " + finder.getClass().getName());
            }
            ruleLoader = finder.findLoader(digester, pluginClass, props);
        }
    }
    catch(PluginException e) {
        throw new PluginException(
            "Unable to locate plugin rules for plugin"
            + " with id [" + id + "]"
            + ", and class [" + pluginClass.getName() + "]"
            + ":" + e.getMessage(), e.getCause());
    }
    log.debug("scanned ruleFinders.");
    
    return ruleLoader;
}
 

/**
 *  Initialize the digester.
 */
private Digester initDigester() {
    URL rulesUrl = this.getClass().getResource(VALIDATOR_RULES);
    if (rulesUrl == null) {
        // Fix for Issue# VALIDATOR-195
        rulesUrl = ValidatorResources.class.getResource(VALIDATOR_RULES);
    }
    if (getLog().isDebugEnabled()) {
        getLog().debug("Loading rules from '" + rulesUrl + "'");
    }
    Digester digester = DigesterLoader.createDigester(rulesUrl);
    digester.setNamespaceAware(true);
    digester.setValidating(true);
    digester.setUseContextClassLoader(true);

    // Add rules for arg0-arg3 elements
    addOldArgRules(digester);

    // register DTDs
    for (int i = 0; i < REGISTRATIONS.length; i += 2) {
        URL url = this.getClass().getResource(REGISTRATIONS[i + 1]);
        if (url != null) {
            digester.register(REGISTRATIONS[i], url.toString());
        }
    }
    return digester;
}
 

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

@SuppressWarnings("deprecation")
protected void setBarChartRules(Digester digester)
{
	String barChartPattern = "*/componentElement/barChart";
	digester.addFactoryCreate(barChartPattern, BarChartXmlFactory.class.getName());
	
	String titleExpressionPattern = barChartPattern + "/titleExpression";
	digester.addFactoryCreate(titleExpressionPattern, JRExpressionFactory.StringExpressionFactory.class.getName());
	digester.addCallMethod(titleExpressionPattern, "setText", 0);
	digester.addSetNext(titleExpressionPattern, "setTitleExpression", JRExpression.class.getName());
	
	String barDatasetPattern = barChartPattern + "/barDataset";
	digester.addObjectCreate(barDatasetPattern, DesignBarDataset.class.getName());
	digester.addSetNext(barDatasetPattern, "setDataset", BarDataset.class.getName());
	
	String barSeriesPattern = barDatasetPattern + "/barSeries";
	digester.addObjectCreate(barSeriesPattern, DefaultBarSeries.class.getName());
	digester.addSetNext(barSeriesPattern, "addSeries", BarSeries.class.getName());

	String seriesExpressionPattern = barSeriesPattern + "/seriesExpression";
	digester.addFactoryCreate(seriesExpressionPattern, JRExpressionFactory.StringExpressionFactory.class.getName());
	digester.addCallMethod(seriesExpressionPattern, "setText", 0);
	digester.addSetNext(seriesExpressionPattern, "setSeriesExpression", JRExpression.class.getName());

	String categoryExpressionPattern = barSeriesPattern + "/categoryExpression";
	digester.addFactoryCreate(categoryExpressionPattern, JRExpressionFactory.StringExpressionFactory.class.getName());
	digester.addCallMethod(categoryExpressionPattern, "setText", 0);
	digester.addSetNext(categoryExpressionPattern, "setCategoryExpression", JRExpression.class.getName());

	String valueExpressionPattern = barSeriesPattern + "/valueExpression";
	digester.addFactoryCreate(valueExpressionPattern, JRExpressionFactory.NumberExpressionFactory.class.getName());
	digester.addCallMethod(valueExpressionPattern, "setText", 0);
	digester.addSetNext(valueExpressionPattern, "setValueExpression", JRExpression.class.getName());
}
 

public  void digestStatistics(Reader reader, String sysid) throws ConfigurationException {
		
		Reader fileReader = new EncapsulatingReader(reader, "<"+ROOT_ELEM_NAME+">", "</"+ROOT_ELEM_NAME+">", false);
		Digester digester = new Digester();
		digester.setUseContextClassLoader(true);

		// push config on the stack
		digester.push(this);
 
		try {
//			String prefix="/"+ROOT_ELEM_NAME+"/";
			String prefix="*/";
			digester.addSetProperties(prefix+"statisticsCollection"); // timestamp info
			digester.addSetProperties(prefix+"statisticsCollection/statgroup"); // instance info
			digester.addObjectCreate (prefix+"statisticsCollection/statgroup/statgroup",SummaryRecord.class); // adapterinfo
			digester.addSetProperties(prefix+"statisticsCollection/statgroup/statgroup"); 
			digester.addSetNext      (prefix+"statisticsCollection/statgroup/statgroup","registerRecord");
			digester.addObjectCreate (prefix+"statisticsCollection/statgroup/statgroup/stat/interval/item",Item.class); // adapterinfo
			digester.addSetProperties(prefix+"statisticsCollection/statgroup/statgroup/stat/interval/item"); 
			digester.addSetNext      (prefix+"statisticsCollection/statgroup/statgroup/stat/interval/item","registerItem");
				
			InputSource is= new InputSource(fileReader);
				
			digester.parse(is);

		} catch (Exception e) {
			// wrap exception to be sure it gets rendered via the IbisException-renderer
			throw new ConfigurationException("error during parsing of file ["+sysid +"]", e);
		}
	}
 

/**
 * @see org.kuali.kfs.sys.batch.BatchInputFileType#parse(byte[])
 */
public Object parse(byte[] fileByteContent) throws ParseException {
    if (fileByteContent == null) {
        LOG.error("an invalid(null) argument was given");
        throw new IllegalArgumentException("an invalid(null) argument was given");
    }

    // handle zero byte contents, xml parsers don't deal with them well
    if (fileByteContent.length == 0) {
        LOG.error("an invalid argument was given, empty input stream");
        throw new IllegalArgumentException("an invalid argument was given, empty input stream");
    }

    // validate contents against schema
    ByteArrayInputStream validateFileContents = new ByteArrayInputStream(fileByteContent);
    validateContentsAgainstSchema(getSchemaLocation(), validateFileContents);

    // setup digester for parsing the xml file
    Digester digester = buildDigester(getSchemaLocation(), getDigestorRulesFileName());

    Object parsedContents = null;
    try {
        ByteArrayInputStream parseFileContents = new ByteArrayInputStream(fileByteContent);
        parsedContents = digester.parse(parseFileContents);
    }
    catch (Exception e) {
        LOG.error("Error parsing xml contents", e);
        throw new ParseException("Error parsing xml contents: " + e.getMessage(), e);
    }

    return parsedContents;    
}
 

/**
 * @return fully-initialized Digester used to process entry XML files
 */
private Digester buildDigester(String schemaLocation, String digestorRulesFileName) {
    Digester digester = new Digester();
    digester.setNamespaceAware(false);
    digester.setValidating(true);
    digester.setErrorHandler(new XmlErrorHandler());
    digester.setSchema(schemaLocation);

    Rules rules = loadRules(digestorRulesFileName);

    digester.setRules(rules);

    return digester;
}
 

/**
 * If there exists a property with the name matching constructor param
 * ruleClassAttr, then load the specified class, locate the appropriate 
 * rules-adding method on that class, and return an object encapsulating 
 * that info.
 * <p>
 * If there is no matching property provided, then just return null.
 * <p>
 * The returned object (when non-null) will invoke the target method
 * on the selected class 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>
 * <p>
 * The target method can be specified in several ways. If this object's
 * constructor was passed a non-null methodAttr parameter, and the
 * properties defines a value with that key, then that is taken as the
 * target method name. If there is no matching property, or the constructor
 * was passed null for methodAttr, then the dfltMethodName passed to the
 * constructor is used as the name of the method on the target class. And
 * if that was null, then DFLT_METHOD_NAME will be used.
 * <p>
 * When the user explicitly declares a plugin in the input xml, the
 * xml attributes on the declaration tag are passed here as properties,
 * so the user can select any class in the classpath (and any method on
 * that class provided it has the correct prototype) as the source of
 * dynamic rules for the plugged-in class.
 */
@Override
public RuleLoader findLoader(Digester digester, Class<?> pluginClass, 
                    Properties p) throws PluginException {

    String ruleClassName = p.getProperty(ruleClassAttr);
    if (ruleClassName == null) {
        // nope, user hasn't requested dynamic rules to be loaded
        // from a specific class.
        return null;
    }
    
    // ok, we are in business
    String methodName = null;
    if (methodAttr != null) { 
        methodName = p.getProperty(methodAttr);
    }
    if (methodName == null) {
        methodName = dfltMethodName;
    }
    if (methodName == null) {
        methodName = DFLT_METHOD_NAME;
    }
    
    Class<?> ruleClass;
    try {
        // load the plugin class object
        ruleClass = 
            digester.getClassLoader().loadClass(ruleClassName);
    } catch(ClassNotFoundException cnfe) {
        throw new PluginException(
            "Unable to load class " + ruleClassName, cnfe);
    }

    return new LoaderFromClass(ruleClass, methodName);
}
 

/**
 * @return Rules loaded from the appropriate XML file
 */
protected Rules loadRules(String digestorRulesFileName) {
    // locate Digester rules
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    URL rulesUrl = classLoader.getResource(digestorRulesFileName);
    if (rulesUrl == null) {
        throw new RuntimeException("unable to locate digester rules file " + digestorRulesFileName);
    }

    // create and init digester
    Digester digester = DigesterLoader.createDigester(rulesUrl);

    return digester.getRules();
}
 

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