runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/xml/SpecBeanDefinitionParser.java

   1 package org.argeo.slc.core.execution.xml;
   2
   3 import java.util.List;
   4
   5 import org.apache.commons.logging.Log;
   6 import org.apache.commons.logging.LogFactory;
   7 import org.argeo.slc.core.execution.DefaultExecutionSpec;
   8 import org.argeo.slc.core.execution.PrimitiveSpecAttribute;
   9 import org.argeo.slc.core.execution.RefSpecAttribute;
  10 import org.argeo.slc.core.execution.RefValueChoice;
  11 import org.springframework.beans.factory.config.BeanDefinition;
  12 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
  13 import org.springframework.beans.factory.support.ManagedList;
  14 import org.springframework.beans.factory.support.ManagedMap;
  15 import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
  16 import org.springframework.beans.factory.xml.ParserContext;
  17 import org.springframework.util.StringUtils;
  18 import org.springframework.util.xml.DomUtils;
  19 import org.w3c.dom.Element;
  20
  21 public class SpecBeanDefinitionParser extends
  22                 AbstractSingleBeanDefinitionParser {
  23         private Log log = LogFactory.getLog(SpecBeanDefinitionParser.class);
  24
  25         @SuppressWarnings("unchecked")
  26         @Override
  27         protected void doParse(Element element, ParserContext parserContext,
  28                         BeanDefinitionBuilder builder) {
  29                 ManagedMap attributes = new ManagedMap();
  30
  31                 // Primitives
  32                 for (Element child : (List<Element>) DomUtils
  33                                 .getChildElementsByTagName(element, "primitive")) {
  34                         BeanDefinitionBuilder childBuilder = BeanDefinitionBuilder
  35                                         .genericBeanDefinition(PrimitiveSpecAttribute.class);
  36                         addCommonProperties(child, parserContext, childBuilder);
  37
  38                         String type = child.getAttribute("type");
  39                         if (StringUtils.hasText(type))
  40                                 childBuilder.addPropertyValue("type", type);
  41
  42                         putInAttributes(attributes, child,
  43                                         childBuilder.getBeanDefinition(), "primitive");
  44                 }
  45
  46                 // Refs
  47                 for (Element refAttrElem : (List<Element>) DomUtils
  48                                 .getChildElementsByTagName(element, "ref")) {
  49                         BeanDefinitionBuilder refAttrBuilder = BeanDefinitionBuilder
  50                                         .genericBeanDefinition(RefSpecAttribute.class);
  51                         addCommonProperties(refAttrElem, parserContext, refAttrBuilder);
  52
  53                         String targetClassName = refAttrElem.getAttribute("targetClass");
  54                         if (StringUtils.hasText(targetClassName))
  55                                 refAttrBuilder.addPropertyValue("targetClass", targetClassName);
  56
  57                         // Choices
  58                         Element choicesElem = DomUtils.getChildElementByTagName(
  59                                         refAttrElem, "choices");
  60                         if (choicesElem != null) {
  61                                 List<Element> choices = DomUtils.getChildElementsByTagName(
  62                                                 choicesElem, "choice");
  63                                 ManagedList choiceBeans = new ManagedList(choices.size());
  64                                 for (Element choiceElem : choices) {
  65                                         BeanDefinitionBuilder choiceBuilder = BeanDefinitionBuilder
  66                                                         .genericBeanDefinition(RefValueChoice.class);
  67                                         choiceBuilder.addPropertyValue("name", choiceElem
  68                                                         .getAttribute("name"));
  69                                         String desc = choiceElem.getAttribute("description");
  70                                         if (StringUtils.hasText(desc))
  71                                                 choiceBuilder.addPropertyValue("description", desc);
  72
  73                                         choiceBeans.add(choiceBuilder.getBeanDefinition());
  74                                 }
  75                                 refAttrBuilder.addPropertyValue("choices", choiceBeans);
  76                         }
  77
  78                         putInAttributes(attributes, refAttrElem, refAttrBuilder
  79                                         .getBeanDefinition(), "ref");
  80                 }
  81
  82                 builder.addPropertyValue("attributes", attributes);
  83         }
  84
  85         protected void addCommonProperties(Element element,
  86                         ParserContext parserContext, BeanDefinitionBuilder specAttr) {
  87                 addBooleanProperty("isParameter", specAttr, element);
  88                 addBooleanProperty("isFrozen", specAttr, element);
  89                 addBooleanProperty("isHidden", specAttr, element);
  90
  91                 Object value = NamespaceUtils.parseValue(element, parserContext,
  92                                 specAttr.getBeanDefinition(), "value");
  93                 if (value != null)
  94                         specAttr.addPropertyValue("value", value);
  95
  96         }
  97
  98         @SuppressWarnings("unchecked")
  99         protected void putInAttributes(ManagedMap attributes, Element child,
 100                         BeanDefinition beanDefinition, String nature) {
 101                 String name = child.getAttribute("name");
 102                 attributes.put(name, beanDefinition);
 103                 if (log.isTraceEnabled())
 104                         log.debug("Added " + nature + " attribute " + name);
 105
 106         }
 107
 108         private void addBooleanProperty(String name,
 109                         BeanDefinitionBuilder specAttr, Element element) {
 110                 String bool = element.getAttribute(name);
 111                 if (StringUtils.hasText(bool))
 112                         specAttr.addPropertyValue(name, Boolean.parseBoolean(bool));
 113
 114         }
 115
 116         @Override
 117         protected Class<DefaultExecutionSpec> getBeanClass(Element element) {
 118                 return DefaultExecutionSpec.class;
 119         }
 120
 121         protected boolean shouldGenerateIdAsFallback() {
 122                 return false;
 123         }
 124
 125 }