View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
6    */
7   package org.mule.transport.soap.axis;
8   
9   import org.mule.config.spring.editors.QNamePropertyEditor;
10  import org.mule.util.ClassUtils;
11  import org.mule.util.StringUtils;
12  
13  import java.util.ArrayList;
14  import java.util.Iterator;
15  import java.util.List;
16  import java.util.StringTokenizer;
17  
18  import javax.xml.namespace.QName;
19  import javax.xml.rpc.ParameterMode;
20  
21  /**
22   * A SOAP method representation where the parameters are named
23   */
24  public class SoapMethod
25  {
26      private QName name;
27      private List namedParameters = new ArrayList();
28      private QName returnType;
29      private Class returnClass = Object.class;
30  
31      public SoapMethod(String methodName, String paramsString) throws ClassNotFoundException
32      {
33          this(QNamePropertyEditor.convert(methodName), paramsString);
34      }
35  
36      /**
37       * Creates a Soap Method using the param string set in the MUle configuration
38       * file
39       * 
40       * @param methodName the name of the method
41       * @param params the param string to parse
42       */
43      public SoapMethod(String methodName, List params) throws ClassNotFoundException
44      {
45          this(QNamePropertyEditor.convert(methodName), params);
46      }
47  
48      public SoapMethod(QName methodName, String paramsString) throws ClassNotFoundException
49      {
50          name = methodName;
51          List params = new ArrayList();
52          for (StringTokenizer stringTokenizer = new StringTokenizer(paramsString, ","); stringTokenizer.hasMoreTokens();)
53          {
54              params.add(stringTokenizer.nextToken().trim());
55          }
56          initParams(params);
57      }
58  
59      public SoapMethod(QName methodName, List params) throws ClassNotFoundException
60      {
61          name = methodName;
62          initParams(params);
63      }
64  
65      private void initParams(List params) throws ClassNotFoundException
66      {
67  
68          NamedParameter param;
69          for (Iterator iterator = params.iterator(); iterator.hasNext();)
70          {
71              String s = (String)iterator.next();
72  
73              for (StringTokenizer tokenizer = new StringTokenizer(s, ";"); tokenizer.hasMoreTokens();)
74              {
75                  String name = tokenizer.nextToken();
76                  String type = tokenizer.nextToken();
77                  if (name.equalsIgnoreCase("return"))
78                  {
79                      if (type.startsWith("qname{"))
80                      {
81                          returnType = QNamePropertyEditor.convert(type);
82                      }
83                      else
84                      {
85                          returnType = NamedParameter.createQName(type);
86                      }
87                  }
88                  else if (name.equalsIgnoreCase("returnClass"))
89                  {
90                      returnClass = ClassUtils.loadClass(type, getClass());
91                  }
92                  else
93                  {
94                      String mode = tokenizer.nextToken();
95                      QName paramName;
96                      if (name.startsWith("qname{"))
97                      {
98                          paramName = QNamePropertyEditor.convert(name);
99                      }
100                     else
101                     {
102                         paramName = new QName(getName().getNamespaceURI(), name, getName().getPrefix());
103                     }
104                     QName qtype;
105                     if (type.startsWith("qname{"))
106                     {
107                         qtype = QNamePropertyEditor.convert(type);
108                     }
109                     else
110                     {
111                         qtype = NamedParameter.createQName(type);
112                     }
113                     param = new NamedParameter(paramName, qtype, mode);
114                     addNamedParameter(param);
115                 }
116             }
117         }
118     }
119 
120     public SoapMethod(QName name)
121     {
122         this.name = name;
123         this.returnType = null;
124     }
125 
126     public SoapMethod(QName name, QName returnType)
127     {
128         this.name = name;
129         this.returnType = returnType;
130     }
131 
132     public SoapMethod(QName name, QName returnType, Class returnClass)
133     {
134         this.name = name;
135         this.returnType = returnType;
136         this.returnClass = returnClass;
137     }
138 
139     public SoapMethod(QName name, Class returnClass)
140     {
141         this.name = name;
142         this.returnClass = returnClass;
143     }
144 
145     public SoapMethod(QName name, List namedParameters, QName returnType)
146     {
147         this.name = name;
148         this.namedParameters = namedParameters;
149         this.returnType = returnType;
150     }
151 
152     public void addNamedParameter(NamedParameter param)
153     {
154         namedParameters.add(param);
155     }
156 
157     public NamedParameter addNamedParameter(QName name, QName type, String mode)
158     {
159         if (StringUtils.isBlank(name.getNamespaceURI()))
160         {
161             name = new QName(getName().getNamespaceURI(), name.getLocalPart(), name.getPrefix());
162         }
163         NamedParameter param = new NamedParameter(name, type, mode);
164         namedParameters.add(param);
165         return param;
166     }
167 
168     public NamedParameter addNamedParameter(QName name, QName type, ParameterMode mode)
169     {
170         if (StringUtils.isBlank(name.getNamespaceURI()))
171         {
172             name = new QName(getName().getNamespaceURI(), name.getLocalPart(), name.getPrefix());
173         }
174         NamedParameter param = new NamedParameter(name, type, mode);
175         namedParameters.add(param);
176         return param;
177     }
178 
179     public void removeNamedParameter(NamedParameter param)
180     {
181         namedParameters.remove(param);
182     }
183 
184     public QName getName()
185     {
186         return name;
187     }
188 
189     public List getNamedParameters()
190     {
191         return namedParameters;
192     }
193 
194     public QName getReturnType()
195     {
196         return returnType;
197     }
198 
199     public void setReturnType(QName returnType)
200     {
201         this.returnType = returnType;
202     }
203 
204     public Class getReturnClass()
205     {
206         return returnClass;
207     }
208 
209     public void setReturnDataType(Class returnClass)
210     {
211         this.returnClass = returnClass;
212     }
213 }