Example usage for org.apache.commons.digester3 Digester addBeanPropertySetter

List of usage examples for org.apache.commons.digester3 Digester addBeanPropertySetter

Introduction

In this page you can find the example usage for org.apache.commons.digester3 Digester addBeanPropertySetter.

Prototype

public void addBeanPropertySetter(String pattern) 

Source Link

Document

Add a "bean property setter" rule for the specified parameters.

Usage

From source file:eu.scape_project.planning.xml.PlanParser.java

private static void addMeasureRules(final Digester digester, final String pattern) {
    digester.addObjectCreate(pattern, Measure.class);
    digester.addSetNext(pattern, "setMeasure");
    digester.addSetProperties(pattern, "ID", "uri");
    digester.addBeanPropertySetter(pattern + "/name");
    digester.addBeanPropertySetter(pattern + "/description");

    PlanParser.addAttributeRules(digester, pattern + "/attribute");
    // scale will be set by global rule
}

From source file:eu.scape_project.planning.xml.PlanParser.java

private static void addAttributeRules(final Digester digester, final String pattern) {
    digester.addObjectCreate(pattern, Attribute.class);
    digester.addSetNext(pattern, "setAttribute");
    digester.addSetProperties(pattern, "ID", "uri");
    digester.addBeanPropertySetter(pattern + "/name");
    digester.addBeanPropertySetter(pattern + "/description");

    digester.addObjectCreate(pattern + "/category", CriterionCategory.class);
    digester.addSetProperties(pattern + "/category", "ID", "uri");
    digester.addSetProperties(pattern + "/category", "scope", "scope");
    digester.addBeanPropertySetter(pattern + "/category/name");
    digester.addSetNext(pattern + "/category", "setCategory");

}

From source file:eu.scape_project.planning.xml.PlanParser.java

private static void addCreateResultValue(final Digester digester, final Class c) {
    String name = c.getName();/*ww w.j av  a2 s  .  com*/
    name = name.substring(name.lastIndexOf(".") + 1);
    name = name.substring(0, 1).toLowerCase() + name.substring(1);

    String pattern = "*/" + name.replace("Value", "Result");
    digester.addObjectCreate(pattern, c);
    digester.addSetProperties(pattern);
    digester.addBeanPropertySetter(pattern + "/value");
    digester.addBeanPropertySetter(pattern + "/comment");
    digester.addSetNext(pattern, "add");
}

From source file:eu.scape_project.planning.xml.PlanParser.java

private static void addCreateValue(final Digester digester, final Class c, final String setNextMethod) {
    String name = c.getName();/* ww w  .j  a va 2s  .  com*/
    name = name.substring(name.lastIndexOf(".") + 1);
    name = name.substring(0, 1).toLowerCase() + name.substring(1);

    String pattern = "*/" + name;
    digester.addObjectCreate(pattern, c);
    // digester.addSetProperties(pattern);
    digester.addBeanPropertySetter(pattern + "/value");
    digester.addSetNext(pattern, setNextMethod);
}

From source file:eu.scape_project.planning.xml.PlanParser.java

/**
 * Adds rules to the digester to parse the a plan XML.
 * //  w w  w.j  a  va 2  s .  co m
 * @param digester
 *            the digester
 * @throws ParserConfigurationException
 *             if an error occurred
 */
private static void addRules(Digester digester) throws ParserConfigurationException {

    ConvertUtils.register(new EnumConverter<EvaluationScope>(EvaluationScope.class), EvaluationScope.class);
    // start with a new file
    digester.addObjectCreate("*/plan", Plan.class);
    digester.addSetProperties("*/plan");
    digester.addSetRoot("*/plan", "setProject");

    digester.addFactoryCreate("*/changelog", ChangeLogFactory.class);
    digester.addSetNext("*/changelog", "setChangeLog");

    digester.addObjectCreate("*/plan/properties", PlanProperties.class);
    digester.addSetProperties("*/plan/properties");
    digester.addSetNext("*/plan/properties", "setPlanProperties");
    digester.addCallMethod("*/plan/properties/description", "setDescription", 0);
    digester.addCallMethod("*/plan/properties/owner", "setOwner", 0);

    digester.addFactoryCreate("*/plan/properties/state", PlanStateFactory.class);
    digester.addSetNext("*/plan/properties/state", "setState");

    PlanParser.addCreateUpload(digester, "*/plan/properties/report", "setReportUpload", DigitalObject.class);

    digester.addObjectCreate("*/plan/basis", ProjectBasis.class);
    digester.addSetProperties("*/plan/basis");
    digester.addSetNext("*/plan/basis", "setProjectBasis");
    digester.addCallMethod("*/plan/basis/applyingPolicies", "setApplyingPolicies", 0);
    digester.addCallMethod("*/plan/basis/designatedCommunity", "setDesignatedCommunity", 0);
    digester.addCallMethod("*/plan/basis/mandate", "setMandate", 0);

    digester.addCallMethod("*/plan/basis/documentTypes", "setDocumentTypes", 0);
    digester.addCallMethod("*/plan/basis/identificationCode", "setIdentificationCode", 0);
    digester.addCallMethod("*/plan/basis/organisationalProcedures", "setOrganisationalProcedures", 0);
    digester.addCallMethod("*/plan/basis/planningPurpose", "setPlanningPurpose", 0);
    digester.addCallMethod("*/plan/basis/planRelations", "setPlanRelations", 0);
    digester.addCallMethod("*/plan/basis/preservationRights", "setPreservationRights", 0);
    digester.addCallMethod("*/plan/basis/referenceToAgreements", "setReferenceToAgreements", 0);

    // define common rule for triggers, for all */triggers/...!
    // also used for PlanDefinition
    digester.addObjectCreate("*/triggers", TriggerDefinition.class);
    digester.addSetNext("*/triggers", "setTriggers");
    // every time a */triggers/trigger is encountered:
    digester.addFactoryCreate("*/triggers/trigger", TriggerFactory.class);
    digester.addSetNext("*/triggers/trigger", "setTrigger");

    //
    // Policy Tree
    //
    digester.addObjectCreate("*/plan/basis/policyTree", PolicyTree.class);
    digester.addSetProperties("*/plan/basis/policyTree");
    digester.addSetNext("*/plan/basis/policyTree", "setPolicyTree");

    digester.addObjectCreate("*/plan/basis/policyTree/policyNode", PolicyNode.class);
    digester.addSetProperties("*/plan/basis/policyTree/policyNode");
    digester.addSetNext("*/plan/basis/policyTree/policyNode", "setRoot");

    digester.addObjectCreate("*/policyNode/policyNode", PolicyNode.class);
    digester.addSetProperties("*/policyNode/policyNode");
    digester.addSetNext("*/policyNode/policyNode", "addChild");

    digester.addObjectCreate("*/policyNode/policy", Policy.class);
    digester.addSetProperties("*/policyNode/policy");
    digester.addSetNext("*/policyNode/policy", "addChild");

    //
    // Sample Records
    //

    digester.addObjectCreate("*/plan/sampleRecords", SampleRecordsDefinition.class);
    digester.addSetProperties("*/plan/sampleRecords");
    digester.addSetNext("*/plan/sampleRecords", "setSampleRecordsDefinition");

    digester.addCallMethod("*/plan/sampleRecords/samplesDescription", "setSamplesDescription", 0);

    // - records
    digester.addObjectCreate("*/record", SampleObject.class);
    digester.addSetProperties("*/record");
    digester.addSetNext("*/record", "addRecord");

    digester.addCallMethod("*/record/description", "setDescription", 0);
    digester.addCallMethod("*/record/originalTechnicalEnvironment", "setOriginalTechnicalEnvironment", 0);

    digester.addObjectCreate("*/record/data", BinaryDataWrapper.class);
    digester.addSetTop("*/record/data", "setData");
    digester.addCallMethod("*/record/data", "setFromBase64Encoded", 0);

    // set up an general rule for all jhove strings!
    digester.addObjectCreate("*/jhoveXML", BinaryDataWrapper.class);
    digester.addSetTop("*/jhoveXML", "setString");
    digester.addCallMethod("*/jhoveXML", "setFromBase64Encoded", 0);
    digester.addCallMethod("*/jhoveXML", "setMethodName", 1, new String[] { "java.lang.String" });
    digester.addObjectParam("*/jhoveXML", 0, "setJhoveXMLString");

    // set up general rule for all fitsXMLs
    digester.addObjectCreate("*/fitsXML", BinaryDataWrapper.class);
    digester.addSetTop("*/fitsXML", "setString");
    digester.addCallMethod("*/fitsXML", "setFromBase64Encoded", 0);
    digester.addCallMethod("*/fitsXML", "setMethodName", 1, new String[] { "java.lang.String" });
    digester.addObjectParam("*/fitsXML", 0, "setFitsXMLString");

    digester.addObjectCreate("*/formatInfo", FormatInfo.class);
    digester.addSetProperties("*/formatInfo");
    digester.addSetNext("*/formatInfo", "setFormatInfo");

    PlanParser.addCreateUpload(digester, "*/record/xcdlDescription", "setXcdlDescription",
            XcdlDescription.class);

    // - collection profile
    digester.addObjectCreate("*/plan/sampleRecords/collectionProfile", CollectionProfile.class);
    digester.addSetProperties("*/plan/sampleRecords/collectionProfile");
    digester.addSetNext("*/plan/sampleRecords/collectionProfile", "setCollectionProfile");

    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/collectionID", "setCollectionID", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/description", "setDescription", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/numberOfObjects", "setNumberOfObjects", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/typeOfObjects", "setTypeOfObjects", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/expectedGrowthRate", "setExpectedGrowthRate",
            0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/retentionPeriod", "setRetentionPeriod", 0);
    PlanParser.addCreateUpload(digester, "*/plan/sampleRecords/collectionProfile/profile", "setProfile",
            DigitalObject.class);

    // requirements definition
    digester.addObjectCreate("*/plan/requirementsDefinition", RequirementsDefinition.class);
    digester.addSetProperties("*/plan/requirementsDefinition");
    digester.addSetNext("*/plan/requirementsDefinition", "setRequirementsDefinition");

    digester.addCallMethod("*/plan/requirementsDefinition/description", "setDescription", 0);

    // - uploads
    digester.addObjectCreate("*/plan/requirementsDefinition/uploads", ArrayList.class);
    digester.addSetNext("*/plan/requirementsDefinition/uploads", "setUploads");
    PlanParser.addCreateUpload(digester, "*/plan/requirementsDefinition/uploads/upload", "add",
            DigitalObject.class);

    // alternatives
    digester.addObjectCreate("*/plan/alternatives", AlternativesDefinition.class);
    digester.addSetProperties("*/plan/alternatives");
    digester.addCallMethod("*/plan/alternatives/description", "setDescription", 0);
    digester.addSetNext("*/plan/alternatives", "setAlternativesDefinition");

    digester.addObjectCreate("*/plan/alternatives/alternative", Alternative.class);
    digester.addSetProperties("*/plan/alternatives/alternative");
    digester.addSetNext("*/plan/alternatives/alternative", "addAlternative");
    // - action
    digester.addObjectCreate("*/plan/alternatives/alternative/action", PreservationActionDefinition.class);
    digester.addSetProperties("*/plan/alternatives/alternative/action");
    digester.addBeanPropertySetter("*/plan/alternatives/alternative/action/descriptor");
    digester.addBeanPropertySetter("*/plan/alternatives/alternative/action/parameterInfo");

    digester.addSetNext("*/plan/alternatives/alternative/action", "setAction");

    digester.addCallMethod("*/plan/alternatives/alternative/description", "setDescription", 0);

    // - - params
    digester.addObjectCreate("*/plan/alternatives/alternative/action/params", LinkedList.class);
    digester.addSetNext("*/plan/alternatives/alternative/action/params", "setParams");

    digester.addObjectCreate("*/plan/alternatives/alternative/action/params/param", Parameter.class);
    digester.addSetProperties("*/plan/alternatives/alternative/action/params/param");
    digester.addSetNext("*/plan/alternatives/alternative/action/params/param", "add");
    // - resource description
    digester.addObjectCreate("*/resourceDescription", ResourceDescription.class);
    digester.addSetProperties("*/resourceDescription");
    digester.addSetNext("*/resourceDescription", "setResourceDescription");

    digester.addCallMethod("*/resourceDescription/configSettings", "setConfigSettings", 0);
    digester.addCallMethod("*/resourceDescription/necessaryResources", "setNecessaryResources", 0);
    digester.addCallMethod("*/resourceDescription/reasonForConsidering", "setReasonForConsidering", 0);

    // - experiment
    digester.addObjectCreate("*/experiment", ExperimentWrapper.class);
    digester.addSetProperties("*/experiment");
    digester.addSetNext("*/experiment", "setExperiment");
    digester.addCallMethod("*/experiment/description", "setDescription", 0);
    digester.addCallMethod("*/experiment/settings", "setSettings", 0);
    PlanParser.addCreateUpload(digester, "*/experiment/workflow", "setWorkflow", DigitalObject.class);

    PlanParser.addCreateUpload(digester, "*/experiment/results/result", null, DigitalObject.class);
    PlanParser.addCreateUpload(digester, "*/result/xcdlDescription", "setXcdlDescription",
            XcdlDescription.class);

    // call function addUpload of ExperimentWrapper
    CallMethodRule r = new CallMethodRule(1, "addResult", 2); // method
                                                              // with
                                                              // two
                                                              // params
                                                              // every time */experiment/uploads/upload is encountered
    digester.addRule("*/experiment/results/result", r);
    // use attribute "key" as first param
    digester.addCallParam("*/experiment/results/result", 0, "key");
    // and the object on stack (DigitalObject) as the second
    digester.addCallParam("*/experiment/results/result", 1, true);

    // addCreateUpload(digester,
    // "*/experiment/xcdlDescriptions/xcdlDescription", null,
    // XcdlDescription.class);
    // // call function addXcdlDescription of ExperimentWrapper
    // r = new CallMethodRule(1, "addXcdlDescription", 2); //method with
    // two
    // params
    // // every time */experiment/xcdlDescriptions/xcdlDescription is
    // encountered
    // digester.addRule("*/experiment/xcdlDescriptions/xcdlDescription",
    // r);
    // // use attribute "key" as first param
    // digester.addCallParam("*/experiment/xcdlDescriptions/xcdlDescription",
    // 0 , "key");http://fue.onb.ac.at/abo/data
    // // and the object on stack (DigitalObject) as the second
    // digester.addCallParam("*/experiment/xcdlDescriptions/xcdlDescription",1,true);

    digester.addObjectCreate("*/experiment/detailedInfos/detailedInfo", DetailedExperimentInfo.class);
    digester.addSetProperties("*/experiment/detailedInfos/detailedInfo");
    digester.addBeanPropertySetter("*/experiment/detailedInfos/detailedInfo/programOutput");
    digester.addBeanPropertySetter("*/experiment/detailedInfos/detailedInfo/cpr");

    // call function "addDetailedInfo" of ExperimentWrapper
    r = new CallMethodRule(1, "addDetailedInfo", 2); // method with two
                                                     // params
                                                     // every time */experiment/detailedInfos/detailedInfo is encountered
    digester.addRule("*/experiment/detailedInfos/detailedInfo", r);
    // use attribute "key" as first param
    digester.addCallParam("*/experiment/detailedInfos/detailedInfo", 0, "key");
    // and the object on stack as second parameter
    digester.addCallParam("*/experiment/detailedInfos/detailedInfo", 1, true);

    // read contained measurements:
    digester.addObjectCreate("*/detailedInfo/measurements/measurement", Measurement.class);
    digester.addSetProperties("*/detailedInfo/measurements/measurement");
    digester.addSetNext("*/detailedInfo/measurements/measurement", "put");
    // values are defined with wild-cards, and therefore set
    // automatically

    /*
     * for each value type a set of rules because of FreeStringValue we need
     * to store the value as XML-element instead of an attribute naming them
     * "ResultValues" wasn't nice too
     */
    PlanParser.addCreateValue(digester, BooleanValue.class, "setValue");
    PlanParser.addCreateValue(digester, FloatRangeValue.class, "setValue");
    PlanParser.addCreateValue(digester, IntegerValue.class, "setValue");
    PlanParser.addCreateValue(digester, IntRangeValue.class, "setValue");
    PlanParser.addCreateValue(digester, OrdinalValue.class, "setValue");
    PlanParser.addCreateValue(digester, PositiveFloatValue.class, "setValue");
    PlanParser.addCreateValue(digester, PositiveIntegerValue.class, "setValue");
    PlanParser.addCreateValue(digester, YanValue.class, "setValue");
    PlanParser.addCreateValue(digester, FreeStringValue.class, "setValue");

    // go no go decision
    digester.addObjectCreate("*/plan/decision", Decision.class);
    digester.addSetProperties("*/plan/decision");
    digester.addSetNext("*/plan/decision", "setDecision");

    digester.addCallMethod("*/plan/decision/actionNeeded", "setActionNeeded", 0);
    digester.addCallMethod("*/plan/decision/reason", "setReason", 0);

    digester.addFactoryCreate("*/plan/decision/goDecision", GoDecisionFactory.class);
    digester.addSetNext("*/plan/decision/goDecision", "setDecision");

    // evaluation
    digester.addObjectCreate("*/plan/evaluation", Evaluation.class);
    digester.addSetProperties("*/plan/evaluation");
    digester.addSetNext("*/plan/evaluation", "setEvaluation");

    digester.addCallMethod("*/plan/evaluation/comment", "setComment", 0);

    // importance weighting
    digester.addObjectCreate("*/plan/importanceWeighting", ImportanceWeighting.class);
    digester.addSetProperties("*/plan/importanceWeighting");
    digester.addSetNext("*/plan/importanceWeighting", "setImportanceWeighting");

    digester.addCallMethod("*/plan/importanceWeighting/comment", "setComment", 0);

    // recommendation
    digester.addObjectCreate("*/plan/recommendation", RecommendationWrapper.class);
    digester.addSetProperties("*/plan/recommendation");
    digester.addSetNext("*/plan/recommendation", "setRecommendation");

    digester.addCallMethod("*/plan/recommendation/reasoning", "setReasoning", 0);
    digester.addCallMethod("*/plan/recommendation/effects", "setEffects", 0);

    // transformation
    digester.addObjectCreate("*/plan/transformation", Transformation.class);
    digester.addSetProperties("*/plan/transformation");
    digester.addSetNext("*/plan/transformation", "setTransformation");

    digester.addCallMethod("*/plan/transformation/comment", "setComment", 0);

    // Tree
    /*
     * Some rules for tree parsing are necessary for importing templates
     * too, that's why they are added by this static method.
     */
    PlanParser.addTreeParsingRulesToDigester(digester);

    digester.addObjectCreate("*/leaf/evaluation", HashMap.class);
    digester.addSetNext("*/leaf/evaluation", "setValueMap");
    /*
     * The valueMap has an entry for each (considered) alternative ... and
     * for each alternative there is a list of values, one per SampleObject.
     * Note: The digester uses a stack, therefore the rule to put the list
     * of values to the valueMap must be added after the rule for adding the
     * values to the list.
     */

    /*
     * 2. and for each alternative there is a list of values, one per
     * SampleObject
     */
    digester.addObjectCreate("*/leaf/evaluation/alternative", Values.class);
    digester.addCallMethod("*/leaf/evaluation/alternative/comment", "setComment", 0);

    /*
     * for each result-type a set of rules they are added to the valueMap by
     * the rules above
     */
    PlanParser.addCreateResultValue(digester, BooleanValue.class);
    PlanParser.addCreateResultValue(digester, FloatValue.class);
    PlanParser.addCreateResultValue(digester, FloatRangeValue.class);
    PlanParser.addCreateResultValue(digester, IntegerValue.class);
    PlanParser.addCreateResultValue(digester, IntRangeValue.class);
    PlanParser.addCreateResultValue(digester, OrdinalValue.class);
    PlanParser.addCreateResultValue(digester, PositiveFloatValue.class);
    PlanParser.addCreateResultValue(digester, PositiveIntegerValue.class);
    PlanParser.addCreateResultValue(digester, YanValue.class);
    PlanParser.addCreateResultValue(digester, FreeStringValue.class);

    /*
     * 1. The valueMap has an entry for each (considered) alternative ...
     */
    // call put of the ValueMap (HashMap)
    r = new CallMethodRule(1, "put", 2);
    digester.addRule("*/leaf/evaluation/alternative", r);
    digester.addCallParam("*/leaf/evaluation/alternative", 0, "key");
    digester.addCallParam("*/leaf/evaluation/alternative", 1, true);

    // digester.addObjectCreate("*/plan/executablePlan/planWorkflow",
    // ExecutablePlanContentWrapper.class);
    // digester.addSetProperties("*/plan/executablePlan/planWorkflow");
    // digester.addSetNext("*/plan/executablePlan/planWorkflow",
    // "setRecommendation");

    // Executable plan definition
    digester.addObjectCreate("*/plan/executablePlan", ExecutablePlanDefinition.class);
    digester.addSetProperties("*/plan/executablePlan");
    digester.addCallMethod("*/plan/executablePlan/objectPath", "setObjectPath", 0);
    digester.addCallMethod("*/plan/executablePlan/toolParameters", "setToolParameters", 0);
    digester.addCallMethod("*/plan/executablePlan/triggersConditions", "setTriggersConditions", 0);
    digester.addCallMethod("*/plan/executablePlan/validateQA", "setValidateQA", 0);
    PlanParser.addCreateUpload(digester, "*/plan/executablePlan/workflow", "setT2flowExecutablePlan",
            DigitalObject.class);

    digester.addSetNext("*/plan/executablePlan", "setExecutablePlanDefinition");

    // Preservation action plan
    digester.addObjectCreate("*/plan/preservationActionPlan", DigitalObject.class);
    digester.addSetNext("*/plan/preservationActionPlan", "setPreservationActionPlan");

    digester.addCallMethod("*/plan/preservationActionPlan", "setContentType", 1);
    digester.addObjectParam("*/plan/preservationActionPlan", 0, "application/xml");
    digester.addCallMethod("*/plan/preservationActionPlan", "setFullname", 1);
    digester.addObjectParam("*/plan/preservationActionPlan", 0, PreservationActionPlanGenerator.FULL_NAME);
    digester.addSetNext("*/plan/preservationActionPlan", "setPreservationActionPlan");

    PlanParser.addCreateXMLData(digester, "*/plan/preservationActionPlan", "setData", "setChangeLog");

    //
    // Import Planets executable plan if present
    //
    // object-create rules are called at the beginning element-tags, in
    // the
    // same order as defined
    // first create the wrapper
    // digester.addObjectCreate("*/plan/executablePlan/planWorkflow",
    // NodeContentWrapper.class);
    // // then an element for workflowConf
    // digester.addRule("*/plan/executablePlan/planWorkflow/workflowConf",
    // new NodeCreateRule());
    //
    // // CallMethod and SetNext rules are called at closing element-tags,
    // // (last
    // // in - first out!)
    //
    // CallMethodRule rr = new CallMethodRule(1, "setNodeContent", 2);
    // digester.addRule("*/plan/executablePlan/planWorkflow/workflowConf",
    // rr);
    // // right below the wrapper is an instance of
    // // ExecutablePlanDefinition
    // digester.addCallParam("*/plan/executablePlan/planWorkflow/workflowConf",
    // 0, 1);
    // // provide the name of the setter method
    // digester.addObjectParam("*/plan/executablePlan/planWorkflow/workflowConf",
    // 1, "setExecutablePlan");
    //
    // // the generated node is not accessible as CallParam (why?!?), but
    // // available for addSetNext
    // digester.addSetNext("*/plan/executablePlan/planWorkflow/workflowConf",
    // "setNode");
    //
    // //
    // // Import EPrints executable plan if present
    // //
    // digester.addObjectCreate("*/plan/executablePlan/eprintsPlan",
    // NodeContentWrapper.class);
    // // then an element for workflowConf
    // digester.addRule("*/plan/executablePlan/eprintsPlan", new
    // NodeCreateRule());
    //
    // CallMethodRule rr2 = new CallMethodRule(1,
    // "setNodeContentEPrintsPlan", 2);
    // digester.addRule("*/plan/executablePlan/eprintsPlan", rr2);
    // // right below the wrapper is an instance of
    // // ExecutablePlanDefinition
    // digester.addCallParam("*/plan/executablePlan/eprintsPlan", 0, 1);
    // // provide the name of the setter method
    // digester.addObjectParam("*/plan/executablePlan/eprintsPlan", 1,
    // "setEprintsExecutablePlan");

    // digester.addSetNext("*/plan/executablePlan/eprintsPlan", "setNode");

    // Plan definition
    digester.addObjectCreate("*/plan/planDefinition", PlanDefinition.class);
    digester.addSetProperties("*/plan/planDefinition");
    digester.addSetNext("*/plan/planDefinition", "setPlanDefinition");

    digester.addCallMethod("*/plan/planDefinition/costsIG", "setCostsIG", 0);
    digester.addCallMethod("*/plan/planDefinition/costsPA", "setCostsPA", 0);
    digester.addCallMethod("*/plan/planDefinition/costsPE", "setCostsPE", 0);
    digester.addCallMethod("*/plan/planDefinition/costsQA", "setCostsQA", 0);
    digester.addCallMethod("*/plan/planDefinition/costsREI", "setCostsREI", 0);
    digester.addCallMethod("*/plan/planDefinition/costsRemarks", "setCostsRemarks", 0);
    digester.addCallMethod("*/plan/planDefinition/costsRM", "setCostsRM", 0);
    digester.addCallMethod("*/plan/planDefinition/costsTCO", "setCostsTCO", 0);
    digester.addCallMethod("*/plan/planDefinition/responsibleExecution", "setResponsibleExecution", 0);
    digester.addCallMethod("*/plan/planDefinition/responsibleMonitoring", "setResponsibleMonitoring", 0);

    digester.addObjectCreate("*/plan/planDefinition/triggers", TriggerDefinition.class);
    digester.addSetNext("*/plan/planDefinition/triggers", "setTriggers");
    // every time a */plan/basis/triggers/trigger is encountered:
    digester.addFactoryCreate("*/plan/planDefinition/triggers/trigger", TriggerFactory.class);
    digester.addSetNext("*/plan/planDefinition/triggers/trigger", "setTrigger");
}

From source file:org.quickserver.net.qsadmin.gui.PropertieSet.java

public static PropertieSet getPropertieSet() {
    PropertieSet ps = null;//from   ww w.  ja v a  2s.c  o m
    try {
        Digester digester = new Digester();
        digester.setValidating(false);
        //digester.setNamespaceAware(true);
        //String xsd = "" + new File("quickserver_config.xsd").toURI();
        //digester.setSchema(xsd);

        //nested QSAdminServer tag
        String mainTag = "propertie-set";
        String subTag = "propertie";
        digester.addObjectCreate(mainTag, PropertieSet.class);
        digester.addObjectCreate(mainTag + "/" + subTag, Propertie.class);
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/name");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/command");
        digester.addCallMethod(mainTag + "/" + subTag + "/get", "setGet", 0);
        digester.addCallMethod(mainTag + "/" + subTag + "/set", "setSet", 0);
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/type");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/desc");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/select");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/target-needed", "targetNeeded");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/version");
        digester.addSetNext(mainTag + "/" + subTag, "addCommand");

        URL configFile = PropertieSet.class
                .getResource("/org/quickserver/net/qsadmin/gui/conf/PropertieSet.xml");
        if (configFile == null)
            throw new RuntimeException("XML File not found : " + "PropertieSet.xml");

        InputStream input = configFile.openStream();
        logger.fine("Loading command config from xml file : " + input);
        ps = (PropertieSet) digester.parse(input);
    } catch (Exception e) {
        logger.severe("Could not init from xml file : " + e);
        logger.fine("StackTrace:\n" + MyString.getStackTrace(e));
    }
    return ps;
}

From source file:org.quickserver.net.qsadmin.gui.SimpleCommandSet.java

public static SimpleCommandSet getSimpleCommands() {
    SimpleCommandSet sms = null;//from   www.j  ava  2 s  .  c  o  m
    try {
        Digester digester = new Digester();
        digester.setValidating(false);
        //digester.setNamespaceAware(true);
        //String xsd = "" + new File("quickserver_config.xsd").toURI();
        //digester.setSchema(xsd);

        //nested QSAdminServer tag
        String mainTag = "simple-command-set";
        String subTag = "simple-command";
        digester.addObjectCreate(mainTag, SimpleCommandSet.class);
        digester.addObjectCreate(mainTag + "/" + subTag, SimpleCommand.class);
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/name");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/command");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/desc");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/target-needed", "targetNeeded");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/multi-line-response", "multiLineResponse");
        digester.addBeanPropertySetter(mainTag + "/" + subTag + "/version");
        digester.addSetNext(mainTag + "/" + subTag, "addCommand");
        URL configFile = SimpleCommandSet.class
                .getResource("/org/quickserver/net/qsadmin/gui/conf/MainCommandPanel.xml");
        if (configFile == null)
            throw new RuntimeException("XML File not found : " + "MainCommandPanel.xml");

        InputStream input = configFile.openStream();
        logger.fine("Loading command config from xml file : " + input);
        sms = (SimpleCommandSet) digester.parse(input);
    } catch (Exception e) {
        logger.severe("Could not init from xml file : " + e);
        logger.fine("StackTrace:\n" + MyString.getStackTrace(e));
    }
    return sms;
}