FlowNamespace extended (flows in flows, param in arg)

[gpl/argeo-slc.git] / runtime / org.argeo.slc.core / src / main / java / org / argeo / slc / core / execution / xml / FlowBeanDefinitionParser.java

diff --git a/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/xml/FlowBeanDefinitionParser.java b/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/xml/FlowBeanDefinitionParser.java
index 306beace251c45e2cc3e2dd31d8969c0bdd9a67f..8594e956e4b375c4185dd3628d17d2ddee228d11 100644 (file)
--- a/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/xml/FlowBeanDefinitionParser.java
+++ b/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/xml/FlowBeanDefinitionParser.java
@@ -5,52 +5,85 @@ import java.util.List;
 
 import org.argeo.slc.SlcException;
 import org.argeo.slc.core.execution.DefaultExecutionFlow;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.ManagedList;
+import org.springframework.beans.factory.support.ManagedMap;
 import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
 import org.springframework.beans.factory.xml.ParserContext;
 import org.springframework.util.StringUtils;
+import org.springframework.util.xml.DomUtils;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
 public class FlowBeanDefinitionParser extends
                AbstractSingleBeanDefinitionParser {
-//     private Log log = LogFactory.getLog(FlowBeanDefinitionParser.class);
+       // private Log log = LogFactory.getLog(FlowBeanDefinitionParser.class);
 
        @SuppressWarnings("unchecked")
        @Override
        protected void doParse(Element element, ParserContext parserContext,
                        BeanDefinitionBuilder builder) {
-               String path = element.getAttribute("lenient");
+               String path = element.getAttribute("path");
                if (StringUtils.hasText(path))
                        builder.addPropertyValue("path", path);
 
-               List<Element> children = new ArrayList<Element>();
+               String spec = element.getAttribute("spec");
+               if (StringUtils.hasText(spec))
+                       builder.getBeanDefinition().getConstructorArgumentValues()
+                                       .addGenericArgumentValue(new RuntimeBeanReference(spec));
+
+               String abstrac = element.getAttribute("abstract");
+               if (StringUtils.hasText(abstrac))
+                       builder.setAbstract(Boolean.parseBoolean(abstrac));
+
+               String parent = element.getAttribute("parent");
+               if (StringUtils.hasText(parent))
+                       builder.setParentName(parent);
+
+               
+               builder.getBeanDefinition().setDescription(DomUtils.getChildElementValueByTagName(element, 
+                               "description"));
+               
+               List<Element> execElems = new ArrayList<Element>();
+               List<Element> argsElems = new ArrayList<Element>();
                NodeList nodeList = element.getChildNodes();
                for (int i = 0; i < nodeList.getLength(); i++) {
                        Node node = nodeList.item(i);
-                       if (node instanceof Element)
-                               children.add((Element) node);
+                       if (node instanceof Element) {
+                               if (DomUtils.nodeNameEquals(node, "arg"))
+                                       argsElems.add((Element) node);
+                               else if(!DomUtils.nodeNameEquals(node, "description"))
+                                       execElems.add((Element) node);
+                       }
                }
-               // children.addAll(DomUtils.getChildElementsByTagName(element, "bean"));
-               // children.addAll(DomUtils.getChildElementsByTagName(element, "ref"));
 
-               ManagedList executables = new ManagedList(children.size());
-               for (int i = 0; i < children.size(); i++) {
-                       Element child = children.get(i);
-                       String name = child.getNodeName();
-                       if ("bean".equals(name) || "ref".equals(name)) {
-                               Object target = parseBeanReference(element, (Element) child,
-                                               parserContext, builder);
-                               executables.add(target);
-                       } else if ("flow".equals(name)) {
-                               // TODO
-                       } else {
-                               throw new SlcException("Unsupported children '" + name + "'");
+               // Arguments
+               if (argsElems.size() != 0) {
+                       ManagedMap args = new ManagedMap(argsElems.size());
+                       for (Element argElem : argsElems) {
+                               Object value = NamespaceUtils.parseValue(argElem,
+                                               parserContext, builder.getBeanDefinition(), null);
+                               if (value != null)
+                                       args.put(argElem.getAttribute("name"), value);
+                               else
+                                       throw new SlcException("No value defined.");
                        }
+                       builder.getBeanDefinition().getConstructorArgumentValues()
+                                       .addGenericArgumentValue(args);
+               }
+
+               // Executables
+               if (execElems.size() != 0) {
+                       ManagedList executables = new ManagedList(execElems.size());
+                       for(Element child : execElems) {
+                               // child validity check is performed in xsd  
+                               executables.add(NamespaceUtils.parseBeanOrReference(child,
+                                               parserContext, builder.getBeanDefinition()));                           
+                       }
+                       builder.addPropertyValue("executables", executables);
                }
-               builder.addPropertyValue("executables", executables);
        }
 
        @Override
@@ -59,11 +92,11 @@ public class FlowBeanDefinitionParser extends
        }
 
        // parse nested bean definition
-       private Object parseBeanReference(Element parent, Element element,
-                       ParserContext parserContext, BeanDefinitionBuilder builder) {
-               return parserContext.getDelegate().parsePropertySubElement(element,
-                               builder.getBeanDefinition());
-       }
+       // private Object parseBeanReference(Element element,
+       // ParserContext parserContext, BeanDefinitionBuilder builder) {
+       // return parserContext.getDelegate().parsePropertySubElement(element,
+       // builder.getBeanDefinition());
+       // }
 
        protected boolean shouldGenerateIdAsFallback() {
                return true;