Improve execution core

[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..56ead5146ed008f943ce459b23018605b045311f 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,64 +5,129 @@ import java.util.List;
 
 import org.argeo.slc.SlcException;
 import org.argeo.slc.core.execution.DefaultExecutionFlow;
+import org.argeo.slc.execution.ExecutionFlow;
+import org.springframework.beans.factory.BeanDefinitionStoreException;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
 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);
+                       }
+               }
+
+               // 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);
                }
-               // 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 + "'");
+
+               // 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()));
                        }
+                       if (executables.size() > 0)
+                               builder.addPropertyValue("executables", executables);
                }
-               builder.addPropertyValue("executables", executables);
        }
 
+       @SuppressWarnings("unchecked")
        @Override
-       protected Class<DefaultExecutionFlow> getBeanClass(Element element) {
-               return DefaultExecutionFlow.class;
+       protected Class<? extends ExecutionFlow> getBeanClass(Element element) {
+               String clss = element.getAttribute("class");
+               if (StringUtils.hasText(clss))
+                       // TODO: check that it actually works
+                       try {
+                               return (Class<? extends ExecutionFlow>) getClass()
+                                               .getClassLoader().loadClass(clss);
+                       } catch (ClassNotFoundException e) {
+                               try {
+                                       return (Class<? extends ExecutionFlow>) Thread
+                                                       .currentThread().getContextClassLoader().loadClass(
+                                                                       clss);
+                               } catch (ClassNotFoundException e1) {
+                                       throw new SlcException("Cannot load class " + clss, e);
+                               }
+                       }
+               else
+                       return DefaultExecutionFlow.class;
        }
 
        // 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());
+       // }
+
+       @Override
+       protected String resolveId(Element element,
+                       AbstractBeanDefinition definition, ParserContext parserContext)
+                       throws BeanDefinitionStoreException {
+               String name = element.getAttribute("name");
+               if (StringUtils.hasText(name)) {
+                       return name;
+               } else {
+                       return super.resolveId(element, definition, parserContext);
+               }
        }
 
        protected boolean shouldGenerateIdAsFallback() {