View Javadoc

1   package org.codehaus.xfire.service;
2   
3   import java.lang.reflect.Method;
4   import java.util.Collection;
5   import java.util.Collections;
6   import java.util.HashMap;
7   import java.util.Iterator;
8   import java.util.Map;
9   
10  import javax.xml.namespace.QName;
11  
12  /***
13   * Represents the description of a service operation. An operation has a name, and consists of a number of in and out
14   * parameters.
15   * <p/>
16   * Operations are created using the {@link ServiceInfo#addOperation} method.
17   *
18   * @author <a href="mailto:dan@envoisolutions.com">Dan Diephouse</a>
19   * @author <a href="mailto:poutsma@mac.com">Arjen Poutsma</a>
20   */
21  public class OperationInfo
22          implements Visitable
23  {
24      private String name;
25      private String action;
26      private ServiceInfo service;
27      private String mep;
28      private boolean async;
29      private MessageInfo inputMessage;
30      private MessageInfo outputMessage;
31      // maps string names to FaultInfo objects
32      private Map faults = new HashMap();
33      private Method method;
34  
35      /***
36       * Initializes a new instance of the <code>OperationInfo</code> class with the given name and service.
37       *
38       * @param name    the name of the operation.
39       * @param service the service.
40       */
41      OperationInfo(String name, Method method, ServiceInfo service)
42      {
43          this.name = name;
44          this.service = service;
45          this.method = method;
46      }
47  
48      /***
49       * Returns the name of the operation.
50       *
51       * @return the name of the operation.
52       */
53      public String getName()
54      {
55          return name;
56      }
57  
58      /***
59       * Sets the name of the operation.
60       *
61       * @param name the new name of the operation.
62       */
63      public void setName(String name)
64      {
65          if ((name == null) || (name.length() == 0))
66          {
67              throw new IllegalArgumentException("Invalid name [" + name + "]");
68          }
69  
70          service.removeOperation(this.name);
71          this.name = name;
72          service.addOperation(this);
73      }
74  
75      public Method getMethod()
76      {
77          return method;
78      }
79  
80      /***
81       * Whether or not the operation should be invoked asynchronously.
82       * 
83       * @return
84       */
85      public boolean isAsync()
86      {
87          return async;
88      }
89  
90      public void setAsync(boolean async)
91      {
92          this.async = async;
93      }
94  
95      /***
96       * Get the message exchange pattern of this operation.
97       * @return
98       */
99      public String getMEP()
100     {
101         return mep;
102     }
103 
104     public void setMEP(String mep)
105     {
106         this.mep = mep;
107     }
108 
109     /***
110      * Returns the service descriptor of this operation.
111      *
112      * @return the service.
113      */
114     public ServiceInfo getService()
115     {
116         return service;
117     }
118 
119     /***
120      * Creates a new message. This message can be set as either {@link #setInputMessage(MessageInfo) input message} or
121      * {@link #setOutputMessage(MessageInfo) output message}.
122      *
123      * @param name the name of the message.
124      * @return the created message.
125      */
126     public MessageInfo createMessage(QName name)
127     {
128         MessageInfo message = new MessageInfo(name, this);
129         return message;
130     }
131 
132     /***
133      * Returns the input message info.
134      *
135      * @return the input message info.
136      */
137     public MessageInfo getInputMessage()
138     {
139         return inputMessage;
140     }
141 
142     /***
143      * Sets the input message info.
144      *
145      * @param inputMessage the input message info.
146      */
147     public void setInputMessage(MessageInfo inputMessage)
148     {
149         this.inputMessage = inputMessage;
150     }
151 
152     /***
153      * Returns the output message info.
154      *
155      * @return the output message info.
156      */
157     public MessageInfo getOutputMessage()
158     {
159         return outputMessage;
160     }
161 
162     /***
163      * Sets the output message info.
164      *
165      * @param outputMessage the output message info.
166      */
167     public void setOutputMessage(MessageInfo outputMessage)
168     {
169         this.outputMessage = outputMessage;
170     }
171 
172     /***
173      * Adds an fault to this operation.
174      *
175      * @param name the fault name.
176      */
177     public FaultInfo addFault(String name)
178     {
179         if ((name == null) || (name.length() == 0))
180         {
181             throw new IllegalArgumentException("Invalid name [" + name + "]");
182         }
183         if (faults.containsKey(name))
184         {
185             throw new IllegalArgumentException("A fault with name [" + name + "] already exists in this operation");
186         }
187         FaultInfo fault = new FaultInfo(name, this);
188         addFault(fault);
189         return fault;
190     }
191 
192     /***
193      * Adds a fault to this operation.
194      *
195      * @param fault the fault.
196      */
197     void addFault(FaultInfo fault)
198     {
199         faults.put(fault.getName(), fault);
200     }
201 
202     /***
203      * Removes a fault from this operation.
204      *
205      * @param name the qualified fault name.
206      */
207     public void removeFault(String name)
208     {
209         faults.remove(name);
210     }
211 
212     /***
213      * Returns the fault with the given name, if found.
214      *
215      * @param name the name.
216      * @return the fault; or <code>null</code> if not found.
217      */
218     public FaultInfo getFault(String name)
219     {
220         return (FaultInfo) faults.get(name);
221     }
222 
223     /***
224      * Returns all faults for this operation.
225      *
226      * @return all faults.
227      */
228     public Collection getFaults()
229     {
230         return Collections.unmodifiableCollection(faults.values());
231     }
232 
233     public String getAction()
234     {
235         return action;
236     }
237 
238     public void setAction(String action)
239     {
240         this.action = action;
241     }
242 
243     /***
244      * Acceps the given visitor. Iterates over the input and output messages, if set.
245      *
246      * @param visitor the visitor.
247      */
248     public void accept(Visitor visitor)
249     {
250         visitor.startOperation(this);
251         if (inputMessage != null)
252         {
253             inputMessage.accept(visitor);
254         }
255         if (outputMessage != null)
256         {
257             outputMessage.accept(visitor);
258         }
259         for (Iterator iterator = faults.values().iterator(); iterator.hasNext();)
260         {
261             FaultInfo faultInfo = (FaultInfo) iterator.next();
262             faultInfo.accept(visitor);
263         }
264         visitor.endOperation(this);
265     }
266 }