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

   1 package org.argeo.slc.core.execution.xml;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import org.argeo.slc.SlcException;
   7 import org.argeo.slc.core.execution.DefaultExecutionFlow;
   8 import org.springframework.beans.factory.config.RuntimeBeanReference;
   9 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
  10 import org.springframework.beans.factory.support.ManagedList;
  11 import org.springframework.beans.factory.support.ManagedMap;
  12 import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
  13 import org.springframework.beans.factory.xml.ParserContext;
  14 import org.springframework.util.StringUtils;
  15 import org.springframework.util.xml.DomUtils;
  16 import org.w3c.dom.Element;
  17 import org.w3c.dom.Node;
  18 import org.w3c.dom.NodeList;
  19
  20 public class FlowBeanDefinitionParser extends
  21                 AbstractSingleBeanDefinitionParser {
  22         // private Log log = LogFactory.getLog(FlowBeanDefinitionParser.class);
  23
  24         @SuppressWarnings("unchecked")
  25         @Override
  26         protected void doParse(Element element, ParserContext parserContext,
  27                         BeanDefinitionBuilder builder) {
  28                 String path = element.getAttribute("path");
  29                 if (StringUtils.hasText(path))
  30                         builder.addPropertyValue("path", path);
  31
  32                 String spec = element.getAttribute("spec");
  33                 if (StringUtils.hasText(spec))
  34                         builder.getBeanDefinition().getConstructorArgumentValues()
  35                                         .addGenericArgumentValue(new RuntimeBeanReference(spec));
  36
  37                 String abstrac = element.getAttribute("abstract");
  38                 if (StringUtils.hasText(abstrac))
  39                         builder.setAbstract(Boolean.parseBoolean(abstrac));
  40
  41                 String parent = element.getAttribute("parent");
  42                 if (StringUtils.hasText(parent))
  43                         builder.setParentName(parent);
  44
  45                 List<Element> execElems = new ArrayList<Element>();
  46                 List<Element> argsElems = new ArrayList<Element>();
  47                 NodeList nodeList = element.getChildNodes();
  48                 for (int i = 0; i < nodeList.getLength(); i++) {
  49                         Node node = nodeList.item(i);
  50                         if (node instanceof Element) {
  51                                 if (DomUtils.nodeNameEquals(node, "arg"))
  52                                         argsElems.add((Element) node);
  53                                 else
  54                                         execElems.add((Element) node);
  55                         }
  56                 }
  57
  58                 // Arguments
  59                 if (argsElems.size() != 0) {
  60                         ManagedMap args = new ManagedMap(argsElems.size());
  61                         for (Element argElem : argsElems) {
  62                                 Object value = NamespaceUtils.parseValue(argElem,
  63                                                 parserContext, builder.getBeanDefinition(), null);
  64                                 if (value != null)
  65                                         args.put(argElem.getAttribute("name"), value);
  66                                 else
  67                                         throw new SlcException("No value defined.");
  68                         }
  69                         builder.getBeanDefinition().getConstructorArgumentValues()
  70                                         .addGenericArgumentValue(args);
  71                 }
  72
  73                 // Executables
  74                 if (execElems.size() != 0) {
  75                         ManagedList executables = new ManagedList(execElems.size());
  76                         for (int i = 0; i < execElems.size(); i++) {
  77                                 Element child = execElems.get(i);
  78                                 String name = child.getLocalName();
  79                                 if (DomUtils.nodeNameEquals(child, "bean")
  80                                                 || DomUtils.nodeNameEquals(child, "ref")) {
  81                                         // Object target = parseBeanReference((Element) child,
  82                                         // parserContext, builder);
  83                                         executables.add(NamespaceUtils.parseBeanReference(child,
  84                                                         parserContext, builder.getBeanDefinition()));
  85                                 } else if (DomUtils.nodeNameEquals(child, "flow")) {
  86                                         throw new SlcException(
  87                                                         "Nested flows are not yet supported, use a standard ref to another flow.");
  88                                 } else {
  89                                         throw new SlcException("Unsupported child '" + name + "'");
  90                                 }
  91                         }
  92                         builder.addPropertyValue("executables", executables);
  93                 }
  94         }
  95
  96         @Override
  97         protected Class<DefaultExecutionFlow> getBeanClass(Element element) {
  98                 return DefaultExecutionFlow.class;
  99         }
 100
 101         // parse nested bean definition
 102         // private Object parseBeanReference(Element element,
 103         // ParserContext parserContext, BeanDefinitionBuilder builder) {
 104         // return parserContext.getDelegate().parsePropertySubElement(element,
 105         // builder.getBeanDefinition());
 106         // }
 107
 108         protected boolean shouldGenerateIdAsFallback() {
 109                 return true;
 110         }
 111
 112 }