View Javadoc

1   /*
2    * $Id: ExpressionTransformerDefinitionParser.java 22391 2011-07-12 12:00:48Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.config.spring.parsers.specific;
12  
13  import org.mule.config.spring.parsers.delegate.ParentContextDefinitionParser;
14  import org.mule.config.spring.parsers.generic.ChildDefinitionParser;
15  import org.mule.config.spring.parsers.generic.MuleOrphanDefinitionParser;
16  import org.mule.config.spring.parsers.processors.CheckExclusiveAttributesAndChildren;
17  import org.mule.config.spring.parsers.processors.CheckRequiredAttributesWhenNoChildren;
18  import org.mule.expression.ExpressionConfig;
19  import org.mule.expression.transformers.ExpressionArgument;
20  
21  import org.springframework.beans.factory.support.BeanDefinitionBuilder;
22  import org.springframework.beans.factory.support.GenericBeanDefinition;
23  import org.springframework.beans.factory.support.ManagedList;
24  import org.springframework.beans.factory.xml.ParserContext;
25  import org.w3c.dom.Element;
26  
27  /**
28   * This allows a message processor to be defined globally, or embedded within an
29   * endpoint. (as either a normal or response processor).
30   */
31  public class ExpressionTransformerDefinitionParser extends ParentContextDefinitionParser
32  {
33  
34      public ExpressionTransformerDefinitionParser(Class messageProcessor)
35      {
36          super(MuleOrphanDefinitionParser.ROOT_ELEMENT, new ExpressionTransformerOrphanDefinitionParser(
37              messageProcessor, false));
38          otherwise(new ExpressionTransformerChildDefinitionParser("messageProcessor", messageProcessor));
39  
40          registerPreProcessor(
41              new CheckRequiredAttributesWhenNoChildren(new String[][]{{"evaluator", "expression"}},
42                  "return-argument")).registerPreProcessor(
43              new CheckExclusiveAttributesAndChildren(new String[]{"evaluator", "expression"},
44                  new String[]{"return-argument"}))
45              .addIgnored("evaluator")
46              .addIgnored("expression")
47              .addIgnored("custom-evaluator");
48      }
49  
50      protected static void addExpressionArgumentFromAttributes(Element element, BeanDefinitionBuilder builder)
51      {
52          if (element.getAttributeNode("expression") != null)
53          {
54              GenericBeanDefinition objectFactoryBeanDefinition = new GenericBeanDefinition();
55              objectFactoryBeanDefinition.setBeanClass(ExpressionArgument.class);
56              objectFactoryBeanDefinition.getPropertyValues().addPropertyValue("name", "single");
57              objectFactoryBeanDefinition.getPropertyValues().addPropertyValue("optional", false);
58              GenericBeanDefinition objectFactoryBeanDefinition2 = new GenericBeanDefinition();
59              objectFactoryBeanDefinition2.setBeanClass(ExpressionConfig.class);
60              objectFactoryBeanDefinition2.getPropertyValues().addPropertyValue("evaluator",
61                  element.getAttribute("evaluator"));
62              objectFactoryBeanDefinition2.getPropertyValues().addPropertyValue("customEvaluator",
63                  element.getAttribute("custom-evaluator"));
64              objectFactoryBeanDefinition2.getPropertyValues().addPropertyValue("expression",
65                  element.getAttribute("expression"));
66              objectFactoryBeanDefinition.getPropertyValues().addPropertyValue("expressionConfig",
67                  objectFactoryBeanDefinition2);
68              ManagedList list = new ManagedList<ExpressionArgument>(1);
69              list.add(objectFactoryBeanDefinition2);
70              builder.getBeanDefinition().getPropertyValues().addPropertyValue("arguments",
71                  objectFactoryBeanDefinition);
72          }
73      }
74  
75      static class ExpressionTransformerChildDefinitionParser extends ChildDefinitionParser
76      {
77  
78          public ExpressionTransformerChildDefinitionParser(String string, Class messageProcessor)
79          {
80              super(string, messageProcessor);
81          }
82  
83          @Override
84          protected void parseChild(Element element, ParserContext parserContext, BeanDefinitionBuilder builder)
85          {
86              addExpressionArgumentFromAttributes(element, builder);
87              super.parseChild(element, parserContext, builder);
88          }
89      }
90  
91      static class ExpressionTransformerOrphanDefinitionParser extends MuleOrphanDefinitionParser
92      {
93  
94          public ExpressionTransformerOrphanDefinitionParser(Class<?> beanClass, boolean singleton)
95          {
96              super(beanClass, singleton);
97          }
98  
99          @Override
100         protected void doParse(Element element, ParserContext context, BeanDefinitionBuilder builder)
101         {
102             addExpressionArgumentFromAttributes(element, builder);
103             super.doParse(element, context, builder);
104         }
105     }
106 }