List of usage examples for org.apache.commons.digester3 Digester addObjectCreate
public void addObjectCreate(String pattern, Class<?> clazz)
From source file:eu.scape_project.planning.xml.PlanParser.java
/** * Adds rules to the digester to parse the a plan XML. * //from w w w. j ava 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:eu.scape_project.planning.xml.PlanParser.java
/** * Imports the XML representation of templates. * /*w w w.j ava2 s .c om*/ * @param in * the input stream to read from * @return a list of read templates. * @throws PlatoException * if the template cannot be parsed */ public List<TemplateTree> importTemplates(final InputStream in) throws PlatoException { try { Digester digester = new Digester(); // digester.setValidating(true); StrictErrorHandler errorHandler = new StrictErrorHandler(); digester.setErrorHandler(errorHandler); // At the moment XML files for template tree's are only used // internally, // later we will define a schema and use it also for validation digester.push(this); digester.addObjectCreate("*/template", TemplateTree.class); digester.addSetProperties("*/template"); digester.addSetRoot("*/template", "setTemplate"); // digester.addSetNext("*/template/name", "setName"); // digester.addSetNext("*/template/owner", "setOwner"); PlanParser.addTreeParsingRulesToDigester(digester); digester.addObjectCreate("*/template/node", Node.class); digester.addSetProperties("*/template/node"); digester.addSetNext("*/template/node", "addChild"); digester.setUseContextClassLoader(true); templates = new ArrayList<TemplateTree>(); digester.parse(in); // FIXME: /* * for (TemplateTree t : templates) { log.info(t.getName() + * t.getOwner()); } */ return templates; } catch (Exception e) { throw new PlatoException("Failed to parse template tree.", e); } }
From source file:org.apache.commons.digester3.examples.api.addressbook.Main.java
private static void addRules(Digester d) { // -------------------------------------------------- // when we encounter a "person" tag, do the following: // create a new instance of class Person, and push that // object onto the digester stack of objects d.addObjectCreate("address-book/person", Person.class); // map *any* attributes on the tag to appropriate // setter-methods on the top object on the stack (the Person // instance created by the preceeding rule). ////from ww w .j a v a 2 s .c om // For example: // if attribute "id" exists on the xml tag, and method setId // with one parameter exists on the object that is on top of // the digester object stack, then a call will be made to that // method. The value will be type-converted from string to // whatever type the target method declares (where possible), // using the commons ConvertUtils functionality. // // Attributes on the xml tag for which no setter methods exist // on the top object on the stack are just ignored. d.addSetProperties("address-book/person"); // call the addPerson method on the second-to-top object on // the stack (the AddressBook object), passing the top object // on the stack (the recently created Person object). d.addSetNext("address-book/person", "addPerson"); // -------------------------------------------------- // when we encounter a "name" tag, call setName on the top // object on the stack, passing the text contained within the // body of that name element [specifying a zero parameter count // implies one actual parameter, being the body text]. // The top object on the stack will be a person object, because // the pattern address-book/person always triggers the // ObjectCreateRule we added previously. d.addCallMethod("address-book/person/name", "setName", 0); // -------------------------------------------------- // when we encounter an "email" tag, call addEmail on the top // object on the stack, passing two parameters: the "type" // attribute, and the text within the tag body. d.addCallMethod("address-book/person/email", "addEmail", 2); d.addCallParam("address-book/person/email", 0, "type"); d.addCallParam("address-book/person/email", 1); // -------------------------------------------------- // When we encounter an "address" tag, create an instance of class // Address and push it on the digester stack of objects. After // doing that, call addAddress on the second-to-top object on the // digester stack (a "Person" object), passing the top object on // the digester stack (the "Address" object). And also set things // up so that for each child xml element encountered between the start // of the address tag and the end of the address tag, the text // contained in that element is passed to a setXXX method on the // Address object where XXX is the name of the xml element found. d.addObjectCreate("address-book/person/address", Address.class); d.addSetNext("address-book/person/address", "addAddress"); d.addSetNestedProperties("address-book/person/address"); }
From source file:org.apache.commons.digester3.examples.api.catalog.Main.java
private static void addRules(Digester d) { // -------------------------------------------------- // when we encounter the root "catalog" tag, create an // instance of the Catalog class. ///*from w w w. j a v a 2 s.c o m*/ // Note that this approach is different from the approach taken in // the AddressBook example, where an initial "root" object was // explicitly created and pushed onto the digester stack before // parsing started instead // // Either approach is fine. d.addObjectCreate("catalog", Catalog.class); // -------------------------------------------------- // when we encounter a book tag, we want to create a Book // instance. However the Book class doesn't have a default // constructor (one with no arguments), so we can't use // the ObjectCreateRule. Instead, we use the FactoryCreateRule. BookFactory factory = new BookFactory(); d.addFactoryCreate("catalog/book", factory); // and add the book to the parent catalog object (which is // the next-to-top object on the digester object stack). d.addSetNext("catalog/book", "addItem"); // we want each subtag of book to map the text contents of // the tag into a bean property with the same name as the tag. // eg <title>foo</title> --> setTitle("foo") d.addSetNestedProperties("catalog/book"); // ----------------------------------------------- // We are using the "AudioVisual" class to represent both // dvds and videos, so when the "dvd" tag is encountered, // create an AudioVisual object. d.addObjectCreate("catalog/dvd", AudioVisual.class); // add this dvd to the parent catalog object d.addSetNext("catalog/dvd", "addItem"); // We want to map every xml attribute onto a corresponding // property-setter method on the Dvd class instance. However // this doesn't work with the xml attribute "year-made", because // of the internal hyphen. We could use explicit CallMethodRule // rules instead, or use a version of the SetPropertiesRule that // allows us to override any troublesome mappings... // // If there was more than one troublesome mapping, we could // use the method variant that takes arrays of xml-attribute-names // and bean-property-names to override multiple mappings. // // For any attributes not explicitly mapped here, the default // processing is applied, so xml attribute "category" --> setCategory. d.addSetProperties("catalog/dvd", "year-made", "yearMade"); // We also need to tell this AudioVisual object that it is actually // a dvd; we can use the ObjectParamRule to pass a string to any // method. This usage is a little artificial - normally in this // situation there would be separate Dvd and Video classes. // Note also that equivalent behaviour could be implemented by // using factory objects to create & initialise the AudioVisual // objects with their type rather than using ObjectCreateRule. d.addCallMethod("catalog/dvd", "setType", 1); d.addObjectParam("catalog/dvd", 0, "dvd"); // pass literal "dvd" string // Each tag of form "<attr id="foo" value="bar"/> needs to map // to a call to setFoo("bar"). // // This is an alternative to the syntax used for books above (see // method addSetNestedProperties), where the name of the subtag // indicated which property to set. Using this syntax in the xml has // advantages and disadvantages both for the user and the application // developer. It is commonly used with the FactoryCreateRule variant // which allows the target class to be created to be specified in an // xml attribute; this feature of FactoryCreateRule is not demonstrated // in this example, but see the Apache Tomcat configuration files for // an example of this usage. // // Note that despite the name similarity, there is no link // between SetPropertyRule and SetPropertiesRule. d.addSetProperty("catalog/dvd/attr", "id", "value"); // ----------------------------------------------- // and here we repeat the dvd rules, but for the video tag. d.addObjectCreate("catalog/video", AudioVisual.class); d.addSetNext("catalog/video", "addItem"); d.addSetProperties("catalog/video", "year-made", "yearMade"); d.addCallMethod("catalog/video", "setType", 1); d.addObjectParam("catalog/video", 0, "video"); d.addSetProperty("catalog/video/attr", "id", "value"); }
From source file:org.apache.commons.digester3.examples.api.dbinsert.Main.java
private static void addRules(Digester d, java.sql.Connection conn) { // -------------------------------------------------- // when we encounter a "table" tag, do the following: // Create a new instance of class Table, and push that // object onto the digester stack of objects. We only need // this so that when a row is inserted, it can find out what // the enclosing tablename was. ////from w w w .j a va 2s . c om // Note that the object is popped off the stack at the end of the // "table" tag (normal behaviour for ObjectCreateRule). Because we // never added the table object to some parent object, when it is // popped off the digester stack it becomes garbage-collected. That // is fine in this situation; we've done all the necessary work and // don't need the table object any more. d.addObjectCreate("database/table", Table.class); // Map *any* attributes on the table tag to appropriate // setter-methods on the top object on the stack (the Table // instance created by the preceeding rule). We only expect one // attribute, though: a 'name' attribute specifying what table // we are inserting rows into. d.addSetProperties("database/table"); // -------------------------------------------------- // When we encounter a "row" tag, invoke methods on the provided // RowInserterRule instance. // // This rule creates a Row instance and pushes it on the digester // object stack, rather like ObjectCreateRule, so that the column // tags have somewhere to store their information. And when the // </row> end tag is found, the rule will trigger to remove this // object from the stack, and also do an actual database insert. // // Note that the rule instance we are passing to the digester has // been initialised with some useful data (the SQL connection). // // Note also that in this case we are not using the digester's // factory methods to create the rule instance; that's just a // convenience - and obviously not an option for Rule classes // that are not part of the digester core implementation. RowInserterRule rowInserterRule = new RowInserterRule(conn); d.addRule("database/table/row", rowInserterRule); // -------------------------------------------------- // when we encounter a "column" tag, call setColumn on the top // object on the stack, passing two parameters: the "name" // attribute, and the text within the tag body. d.addCallMethod("database/table/row/column", "addColumn", 2); d.addCallParam("database/table/row/column", 0, "name"); d.addCallParam("database/table/row/column", 1); }
From source file:org.apache.commons.digester3.examples.plugins.pipeline.Pipeline.java
public static void main(String[] args) { if (args.length != 1) { System.err.println("usage: pipeline config-file"); System.exit(-1);/* w ww.jav a 2s. c om*/ } String configFile = args[0]; Digester digester = new Digester(); PluginRules rc = new PluginRules(); digester.setRules(rc); digester.addObjectCreate("pipeline", Pipeline.class); digester.addCallMethod("pipeline/source", "setSource", 1); digester.addCallParam("pipeline/source", 0, "file"); PluginCreateRule pcr = new PluginCreateRule(Transform.class); digester.addRule("pipeline/transform", pcr); digester.addSetNext("pipeline/transform", "setTransform"); digester.addCallMethod("pipeline/destination", "setDest", 1); digester.addCallParam("pipeline/destination", 0, "file"); Pipeline pipeline = null; try { pipeline = digester.parse(configFile); } catch (Exception e) { System.err.println("oops exception occurred during parse."); e.printStackTrace(); System.exit(-1); } try { pipeline.execute(); } catch (Exception e) { System.err.println("oops exception occurred during pipeline execution."); e.printStackTrace(); System.exit(-1); } }
From source file:org.azkfw.business.logic.LogicManager.java
/** * ?// www . j a v a2s . com * * @param aNamespace ??? * @param aStream * @param aContext * @throws BusinessServiceException ???????? * @throws IOException ???????? */ @SuppressWarnings("unchecked") private void doLoad(final String aNamespace, final InputStream aStream, final Context aContext) throws BusinessServiceException, IOException { List<LogicEntity> logicList = null; try { Digester digester = new Digester(); digester.addObjectCreate("azuki/logics", ArrayList.class); digester.addObjectCreate("azuki/logics/logic", LogicEntity.class); digester.addSetProperties("azuki/logics/logic"); digester.addSetNext("azuki/logics/logic", "add"); logicList = digester.parse(aStream); } catch (SAXException ex) { error(ex); throw new IOException(ex); } catch (IOException ex) { error(ex); throw new IOException(ex); } Map<String, LogicData> m = null; if (logics.containsKey(aNamespace)) { m = logics.get(aNamespace); } else { m = new HashMap<String, LogicData>(); } for (int i = 0; i < logicList.size(); i++) { LogicEntity logic = logicList.get(i); info("Logic loading.[" + logic.name + "]"); if (m.containsKey(logic.getName())) { throw new BusinessServiceException("Duplicate logic name.[" + logic.getName() + "]"); } else { try { LogicData data = new LogicData(); Class<Logic> clazz = (Class<Logic>) Class.forName(logic.getLogic()); // XXX ???????? Map<String, Object> properties = new HashMap<String, Object>(); PropertyFile propertyFile = clazz.getAnnotation(PropertyFile.class); if (null != propertyFile) { String property = propertyFile.value(); if (StringUtility.isNotEmpty(property)) { InputStream is = aContext.getResourceAsStream(property); if (null != is) { Properties p = new Properties(); p.load(is); for (String key : p.stringPropertyNames()) { properties.put(key, p.getProperty(key)); } } else { throw new BusinessServiceException( "Not found logic property file.[" + property + "]"); } } } data.setLogic(clazz); data.setProperties(properties); data.setEntity(logic); m.put(logic.getName(), data); } catch (ClassNotFoundException ex) { error(ex); throw new BusinessServiceException(ex); } } } logics.put(aNamespace, m); }
From source file:org.azkfw.datasource.xml.XmlDatasourceBuilder.java
/** * ?//from ww w .jav a2 s. c o m * * @return * @throws FileNotFoundException * @throws ParseException * @throws IOException */ @SuppressWarnings({ "unchecked", "rawtypes" }) public Datasource build() throws FileNotFoundException, ParseException, IOException { XmlDatasource datasource = new XmlDatasource(); datasource.name = datasourceName; InputStream stream = null; try { List<XmlTable> tables = new ArrayList<XmlTable>(); for (File file : xmlFiles) { List<XmlTableEntity> tableList = null; stream = new FileInputStream(file); Digester digester = new Digester(); digester.addObjectCreate("datasource/tables", ArrayList.class); digester.addObjectCreate("datasource/tables/table", XmlTableEntity.class); digester.addSetProperties("datasource/tables/table"); digester.addSetNext("datasource/tables/table", "add"); digester.addObjectCreate("datasource/tables/table/fields", ArrayList.class); digester.addSetNext("datasource/tables/table/fields", "setFields"); digester.addObjectCreate("datasource/tables/table/fields/field", XmlFieldEntity.class); digester.addSetProperties("datasource/tables/table/fields/field"); digester.addSetNext("datasource/tables/table/fields/field", "add"); digester.addObjectCreate("datasource/tables/table/records", ArrayList.class); digester.addSetNext("datasource/tables/table/records", "setRecords"); digester.addObjectCreate("datasource/tables/table/records/record", XmlRecordEntity.class); digester.addSetNext("datasource/tables/table/records/record", "add"); digester.addObjectCreate("datasource/tables/table/records/record/data", XmlRecordDataEntity.class); digester.addSetProperties("datasource/tables/table/records/record/data"); digester.addSetNext("datasource/tables/table/records/record/data", "add"); tableList = digester.parse(stream); for (XmlTableEntity t : tableList) { XmlTable table = new XmlTable(); table.label = t.label; table.name = t.name; // Read Field List<XmlField> fields = new ArrayList<XmlField>(); for (int col = 0; col < t.fields.size(); col++) { XmlFieldEntity f = t.fields.get(col); XmlField field = readField(col, f); fields.add(field); } // Read Data List<XmlRecord> records = new ArrayList<XmlRecord>(); for (int row = 0; row < t.records.size(); row++) { XmlRecordEntity r = t.records.get(row); if (r.data.size() == fields.size()) { XmlRecord record = readData(row, r, fields); records.add(record); } else { System.out.println("Skip row(unmatch field count).[table: " + table.getName() + "; row: " + r + ";]"); } } table.fields = (List) fields; table.records = (List) records; tables.add(table); } } datasource.tables = (List) tables; } catch (SAXException ex) { throw new ParseException(ex.getMessage(), -1); } catch (IOException ex) { throw ex; } finally { if (null != stream) { try { stream.close(); } catch (Exception ex) { ex.printStackTrace(); } } } return datasource; }
From source file:org.azkfw.datasource.xml.XmlDatasourceFactory.java
/** * XML???// ww w . ja v a 2s . com * * @param aName ?? * @param aFile XML * @return */ @SuppressWarnings({ "unchecked", "rawtypes" }) public static Datasource generate(final String aName, final File aFile) throws FileNotFoundException, ParseException, IOException { XmlDatasource datasource = new XmlDatasource(); datasource.name = aName; List<XmlTableEntity> tableList = null; InputStream stream = null; try { stream = new FileInputStream(aFile); Digester digester = new Digester(); digester.addObjectCreate("datasource/tables", ArrayList.class); digester.addObjectCreate("datasource/tables/table", XmlTableEntity.class); digester.addSetProperties("datasource/tables/table"); digester.addSetNext("datasource/tables/table", "add"); digester.addObjectCreate("datasource/tables/table/fields", ArrayList.class); digester.addSetNext("datasource/tables/table/fields", "setFields"); digester.addObjectCreate("datasource/tables/table/fields/field", XmlFieldEntity.class); digester.addSetProperties("datasource/tables/table/fields/field"); digester.addSetNext("datasource/tables/table/fields/field", "add"); digester.addObjectCreate("datasource/tables/table/records", ArrayList.class); digester.addSetNext("datasource/tables/table/records", "setRecords"); digester.addObjectCreate("datasource/tables/table/records/record", XmlRecordEntity.class); digester.addSetNext("datasource/tables/table/records/record", "add"); digester.addObjectCreate("datasource/tables/table/records/record/data", XmlRecordDataEntity.class); digester.addSetProperties("datasource/tables/table/records/record/data"); digester.addSetNext("datasource/tables/table/records/record/data", "add"); tableList = digester.parse(stream); } catch (SAXException ex) { throw new ParseException(ex.getMessage(), -1); } catch (IOException ex) { throw ex; } finally { if (null != stream) { try { stream.close(); } catch (Exception ex) { ex.printStackTrace(); } } } List<XmlTable> tables = new ArrayList<XmlTable>(); for (XmlTableEntity t : tableList) { XmlTable table = new XmlTable(); table.label = t.label; table.name = t.name; // Read Field List<XmlField> fields = new ArrayList<XmlField>(); for (int col = 0; col < t.fields.size(); col++) { XmlFieldEntity f = t.fields.get(col); XmlField field = readField(col, f); fields.add(field); } // Read Data List<XmlRecord> records = new ArrayList<XmlRecord>(); for (int row = 0; row < t.records.size(); row++) { XmlRecordEntity r = t.records.get(row); if (r.data.size() == fields.size()) { XmlRecord record = readData(row, r, fields); records.add(record); } else { System.out.println( "Skip row(unmatch field count).[table: " + table.getName() + "; row: " + r + ";]"); } } table.fields = (List) fields; table.records = (List) records; tables.add(table); } datasource.tables = (List) tables; return datasource; }
From source file:org.esupportail.monitor.web.tools.InfosCollector.java
/** * Rcupre les informations d'un serveur distant * @param s L'objet remplit/*from ww w.j ava 2 s. c o m*/ * @return status vrai si tout se passe bien, faux sinon */ public static boolean fetch(ServerInfo s, boolean users) { Digester dig = new Digester(); dig.push(s); dig.addObjectCreate("runtimeinfo/memory", MemoryInfo.class); dig.addSetProperties("runtimeinfo/memory"); dig.addSetNext("runtimeinfo/memory", "setMemory"); dig.addObjectCreate("runtimeinfo/sessions", SessionInfo.class); dig.addSetProperties("runtimeinfo/sessions"); dig.addSetNext("runtimeinfo/sessions", "setSession"); dig.addCallMethod("runtimeinfo/users/user", "addUser", 1); dig.addCallParam("runtimeinfo/users/user", 0, "uid"); URL ressourceUrl = null; try { if (users) { ressourceUrl = new URL(s.getUrl() + "?xml=full"); } else { ressourceUrl = new URL(s.getUrl() + "?xml"); } } catch (MalformedURLException e) { // logger.error(e); System.out.print(e + "\n"); return false; } if (ressourceUrl != null) { try { // On parse le fichier dont le chemin est pass en paramtre dig.parse(new InputSource(ressourceUrl.toExternalForm())); } catch (IOException e) { //logger.error("InfosCollector::fetch() : Impossible d'ouvrir l'URL \n" + e); System.out.print("InfosCollector::fetch() : Impossible d'ouvrir l'URL \n" + e); return false; } catch (SAXException e) { //logger.error("InfosCollector::fetch() : SAXException :\n" + e); System.out.print("InfosCollector::fetch() : SAXException :\n" + e); return false; } catch (Exception e) { //logger.error("InfosCollector::fetch() : Exception :\n" + e); System.out.print("InfosCollector::fetch() : Exception :\n" + e); return false; } } else { //logger.error("InfosCollector::fetch() : L'URL est introuvable"); System.out.print("InfosCollector::fetch() : L'URL est introuvable"); return false; } return true; }