View Javadoc

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