bexee - 0.1

Clover coverage report - bexee - 0.1

Coverage timestamp: Do Dez 16 2004 13:24:06 CET

FRAMES NO FRAMES

file stats:	LOC:	634		Methods:	27
	NCLOC:	403		Classes:	1

30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover

Source file

Conditionals

Statements

Methods

TOTAL

ProcessControllerImpl.java

43.5%

71.2%

63%

63.2%

 /*
  * $Id: ProcessControllerImpl.java,v 1.1 2004/12/15 14:18:10 patforna Exp $
  *
  * Copyright (c) 2004 Patric Fornasier, Pawel Kowalski
  * Berne University of Applied Sciences
  * School of Engineering and Information Technology
  * All rights reserved.
  */
 package bexee.core;
 
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
 import javax.wsdl.Binding;
 import javax.wsdl.Definition;
 import javax.wsdl.Message;
 import javax.wsdl.Operation;
 import javax.wsdl.Part;
 import javax.wsdl.Port;
 import javax.wsdl.PortType;
 import javax.wsdl.extensions.ExtensibilityElement;
 import javax.wsdl.extensions.soap.SOAPAddress;
 import javax.xml.namespace.QName;
 import javax.xml.rpc.ParameterMode;
 
 import org.apache.axis.Constants;
 import org.apache.axis.client.Call;
 import org.apache.axis.client.Service;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import bexee.event.Event;
 import bexee.model.activity.Activity;
 import bexee.model.activity.Assign;
 import bexee.model.activity.Compensate;
 import bexee.model.activity.Empty;
 import bexee.model.activity.Flow;
 import bexee.model.activity.Invoke;
 import bexee.model.activity.Receive;
 import bexee.model.activity.Reply;
 import bexee.model.activity.Sequence;
 import bexee.model.activity.Switch;
 import bexee.model.elements.BpelCase;
 import bexee.model.elements.Copy;
 import bexee.model.elements.Correlation;
 import bexee.model.elements.CorrelationPattern;
 import bexee.model.elements.From;
 import bexee.model.elements.Link;
 import bexee.model.elements.PartnerLink;
 import bexee.model.elements.PartnerLinks;
 import bexee.model.elements.To;
 import bexee.model.elements.Variable;
 import bexee.model.elements.Variables;
 import bexee.model.process.BPELProcess;
 import bexee.model.process.Process;
 
 /**
  * The default imlementation of the <code>ProcessController</code>.
  * 
  * @version $Revision: 1.1 $, $Date: 2004/12/15 14:18:10 $
  * @author Patric Fornasier
  * @author Pawel Kowalski
  */
 public class ProcessControllerImpl implements ProcessController {
 
     private static Log log = LogFactory.getLog(ProcessControllerImpl.class);
 
     //**************************************************/
     // processor entry method
     //**************************************************/
 
     public void processMessage(ProcessInstance instance, BexeeMessage message) {
 
         log.info("Processing a ProcessInstance");
 
         // initialize objects
         //
         ProcessContext ctx = instance.getContext();
         BPELProcess process = instance.getProcess();
 
         ctx.setMessage(message);
 
         // start processing process elements
         try {
             process.getProcess().accept(this, instance);
         } catch (AwaitMessageException e) {
             e.printStackTrace();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
     //**************************************************/
     // process the Process
     //**************************************************/
 
     public void process(Process process, ProcessInstance instance)
             throws Exception {
 
         log.info("Processing a Process");
 
         // process all child elements
         Variables variables = process.getVariables();
         if (variables != null) {
             variables.accept(this, instance);
         }
 
         PartnerLinks partnerLinks = process.getPartnerLinks();
         if (partnerLinks != null) {
             partnerLinks.accept(this, instance);
         }
 
         Activity activity = process.getActivity();
         // there must be one root activity of this process
         if (activity != null) {
             activity.accept(this, instance);
         } else {
             throw new MissingActivityException();
         }
     }
 
     //**************************************************/
     // process structured activities
     //**************************************************/
 
     public void process(Sequence sequence, ProcessInstance instance)
             throws Exception {
 
         log(sequence);
 
         // process all activities in sequence
         List activities = sequence.getActivities();
         for (Iterator iter = activities.iterator(); iter.hasNext();) {
             Activity activity = (Activity) iter.next();
             activity.accept(this, instance);
         }
     }
 
     /**
      * This is the implementation of the Flow activity which is used for
      * parallel execution. In this primitive implementation we don't use any
      * thread pooling mechanisms. In a more sophisticated version of the
      * ProcessController, we might make use of the
      * http://jakarta.apache.org/commons/pool/ library for thread pooling.
      */
     public void process(Flow flow, ProcessInstance instance) throws Exception {
 
         log(flow);
 
         List activities = flow.getActivities();
         int activitiesCount = activities.size();
         Thread[] flowThreads = new Thread[activitiesCount];
 
         // execute activities in separate threads
         // for parallelity
         //
         for (int i = 0; i < activitiesCount; i++) {
             Activity activity = (Activity) activities.get(i);
             flowThreads[i] = new FlowThread(this, instance, activity);
             flowThreads[i].start();
         }
 
         // wait for termination of all started FlowThreads
         for (int i = 0; i < flowThreads.length; i++) {
             flowThreads[i].join();
         }
 
         /**
          * TODO because the run() Thread method is not allowed to throw
          * Exceptions, it is necessary to check the status of each executed
          * Thread in order to know wheter it finished its taks correctly or
          * failed.
          */
     }
 
     /**
      * A default implementation of the
      * <code>process(Switch, ProcessInstance)</code> method.
      *  
      */
     public void process(Switch bpelSwitch, ProcessInstance instance)
             throws Exception {
 
         List bpelCases = bpelSwitch.getCases();
         for (Iterator iter = bpelCases.iterator(); iter.hasNext();) {
             BpelCase bpelCase = (BpelCase) iter.next();
             if (bpelCase.getBooleanExpression().evaluate()) {
                 bpelCase.getCaseActivity().accept(this, instance);
                 return;
             }
         }
 
         Activity otherwise = bpelSwitch.getOtherwise();
         if (otherwise != null) {
             otherwise.accept(this, instance);
         }
     }
 
     //**************************************************/
     // process atomic activities
     //**************************************************/
 
     public void process(Receive receive, ProcessInstance instance)
             throws AwaitMessageException {
 
         log(receive);
 
         // get process context
         ProcessContext ctx = instance.getContext();
         BPELProcess process = instance.getProcess();
 
         Event event = ctx.getEvent(receive);
         if (event == null) {
 
             BexeeMessage message = ctx.removeMessage();
 
             if (message == null) {
                 throw new AwaitMessageException(receive);
             } else {
                 event = new Event(receive);
 
                 // copy received value into context
                 Variable var = receive.getVariable();
                 ctx.setVariable(var, message.getParts());
 
                 ctx.addEvent(event);
             }
         }
     }
 
     public void process(Assign assign, ProcessInstance instance)
             throws Exception {
 
         log(assign);
 
         BPELProcess process = instance.getProcess();
         ProcessContext ctx = instance.getContext();
 
         Event event = ctx.getEvent(assign);
         if (event == null) {
 
             // event creation
             event = new Event(assign);
 
             // get the copy of this assign
             Copy copy = assign.getCopy();
 
             // get from information
             From from = copy.getFrom();
             Variable fromVar = from.getVariable();
             String fromVarPart = from.getPart();
 
             // get to information
             To to = copy.getTo();
             Variable toVar = to.getVariable();
             String toVarPart = to.getPart();
 
             // get the from variable part and assign it
             Object variablePart = ctx.getVariablePart(fromVar, fromVarPart);
 
             // this is some magic just for demonstration purposes
             //
             String responseString = "";
 
             if (assign.getName() != null
                     && assign.getName().indexOf("Response") != -1) {
                 Collection varIds = ctx.getVariablesIdentifiers();
                 for (Iterator iter = varIds.iterator(); iter.hasNext();) {
                     Variable variable = (Variable) iter.next();
                     Collection parts = ctx.getVariable(variable).values();
                     for (Iterator iterator = parts.iterator(); iterator
                             .hasNext();) {
                         Object element = (Object) iterator.next();
                         if (element != null) {
                             responseString += "} {" + element.toString();
                         }
                     }
                 }
                 variablePart = responseString;
             }
 
             ctx.setVariablePart(toVar, toVarPart, variablePart);
             ctx.addEvent(event);
         }
     }
 
     public void process(Invoke invoke, ProcessInstance instance)
             throws Exception {
 
         log(invoke);
 
         // initialize objects
         //
         ProcessContext ctx = instance.getContext();
         BPELProcess process = instance.getProcess();
 
         Event event = ctx.getEvent(invoke);
         if (event == null) {
 
             // event creation
             event = new Event(invoke);
 
             // get in variable value
             Variable inVar = invoke.getInputVariable();
             Map inVarParts = ctx.getVariable(inVar);
             Object[] variablePartsAsArray = inVarParts.values().toArray();
 
             // get out variable value
             Variable outVar = invoke.getOutputVariable();
             Map outVarParts = ctx.getVariable(outVar);
 
             // get infos about the web service to be invoked
             String operationName = invoke.getOperation();
             QName portTypeName = invoke.getPortType();
 
             // traverse definition in order to find information about the call
             Definition definition = findWSDL(portTypeName, process);
             PortType portType = definition.getPortType(portTypeName);
             Operation operationType = portType.getOperation(operationName,
                     null, null);
             Message inMessage = operationType.getInput().getMessage();
             Object[] messageParts = inMessage.getParts().values().toArray();
 
             Binding binding = findBinding(definition, portTypeName);
             Port port = findPort(definition, binding);
             SOAPAddress soapAddress = findSOAPAddress(port);
 
             // build service call
             Service service = new Service();
             Call call = (Call) service.createCall();
             call.setTargetEndpointAddress(soapAddress.getLocationURI());
             call.setPortName(invoke.getPortType());
             call.setOperationName(invoke.getOperation());
 
             // add parameters to the call
             for (int i = 0; i < messageParts.length; i++) {
                 Part messagePart = (Part) messageParts[i];
                 call.addParameter(messagePart.getName(), messagePart
                         .getTypeName(), ParameterMode.IN);
             }
             call.setReturnType(Constants.XSD_STRING);
 
             // this will be the result of the invoke
             Object result = null;
 
             // call synchronously
             if (invoke.isSynchronous()) {
                 result = call.invoke(variablePartsAsArray);
             }
             // call asynchronously
             else {
                 // TODO asynchronous call in new thread
             }
 
             // assign result to the variable
             Variable variable = invoke.getOutputVariable();
             Message outMessage = operationType.getOutput().getMessage();
             Object[] outparts = outMessage.getParts().values().toArray();
             for (int i = 0; i < outparts.length; i++) {
                 Part messagePart = (Part) messageParts[i];
                 ctx.setVariablePart(variable, messagePart.getName(), result);
             }
 
             ctx.addEvent(event);
         }
     }
 
     private Definition findWSDL(QName portTypeName, BPELProcess process) {
 
         Definition definition = null;
         Binding binding = null;
 
         // find the right binding for the portType
         //
         Collection wsdlCollection = process.getPartnerWSDL();
         mainloop: for (Iterator iter = wsdlCollection.iterator(); iter
                 .hasNext();) {
             definition = (Definition) iter.next();
             Collection bindings = definition.getBindings().values();
             for (Iterator iterator = bindings.iterator(); iterator.hasNext();) {
                 binding = (Binding) iterator.next();
                 if (binding.getPortType().getQName().equals(portTypeName)) {
                     break mainloop;
                 }
             }
         }
         return definition;
     }
 
     private Binding findBinding(Definition definition, QName portTypeName) {
 
         Binding binding = null;
 
         Collection bindings = definition.getBindings().values();
         for (Iterator iterator = bindings.iterator(); iterator.hasNext();) {
             binding = (Binding) iterator.next();
             if (binding.getPortType().getQName().equals(portTypeName)) {


1		/*
2		* $Id: ProcessControllerImpl.java,v 1.1 2004/12/15 14:18:10 patforna Exp $
3		*
4		* Copyright (c) 2004 Patric Fornasier, Pawel Kowalski
5		* Berne University of Applied Sciences
6		* School of Engineering and Information Technology
7		* All rights reserved.
8		*/
9		package bexee.core;
10
11		import java.util.Collection;
12		import java.util.Iterator;
13		import java.util.List;
14		import java.util.Map;
15
16		import javax.wsdl.Binding;
17		import javax.wsdl.Definition;
18		import javax.wsdl.Message;
19		import javax.wsdl.Operation;
20		import javax.wsdl.Part;
21		import javax.wsdl.Port;
22		import javax.wsdl.PortType;
23		import javax.wsdl.extensions.ExtensibilityElement;
24		import javax.wsdl.extensions.soap.SOAPAddress;
25		import javax.xml.namespace.QName;
26		import javax.xml.rpc.ParameterMode;
27
28		import org.apache.axis.Constants;
29		import org.apache.axis.client.Call;
30		import org.apache.axis.client.Service;
31		import org.apache.commons.logging.Log;
32		import org.apache.commons.logging.LogFactory;
33
34		import bexee.event.Event;
35		import bexee.model.activity.Activity;
36		import bexee.model.activity.Assign;
37		import bexee.model.activity.Compensate;
38		import bexee.model.activity.Empty;
39		import bexee.model.activity.Flow;
40		import bexee.model.activity.Invoke;
41		import bexee.model.activity.Receive;
42		import bexee.model.activity.Reply;
43		import bexee.model.activity.Sequence;
44		import bexee.model.activity.Switch;
45		import bexee.model.elements.BpelCase;
46		import bexee.model.elements.Copy;
47		import bexee.model.elements.Correlation;
48		import bexee.model.elements.CorrelationPattern;
49		import bexee.model.elements.From;
50		import bexee.model.elements.Link;
51		import bexee.model.elements.PartnerLink;
52		import bexee.model.elements.PartnerLinks;
53		import bexee.model.elements.To;
54		import bexee.model.elements.Variable;
55		import bexee.model.elements.Variables;
56		import bexee.model.process.BPELProcess;
57		import bexee.model.process.Process;
58
59		/**
60		* The default imlementation of the <code>ProcessController</code>.
61		*
62		* @version $Revision: 1.1 $, $Date: 2004/12/15 14:18:10 $
63		* @author Patric Fornasier
64		* @author Pawel Kowalski
65		*/
66		public class ProcessControllerImpl implements ProcessController {
67
68		private static Log log = LogFactory.getLog(ProcessControllerImpl.class);
69
70		//**************************************************/
71		// processor entry method
72		//**************************************************/
73
74	4	public void processMessage(ProcessInstance instance, BexeeMessage message) {
75
76	4	log.info("Processing a ProcessInstance");
77
78		// initialize objects
79		//
80	4	ProcessContext ctx = instance.getContext();
81	4	BPELProcess process = instance.getProcess();
82
83	4	ctx.setMessage(message);
84
85		// start processing process elements
86	4	try {
87	4	process.getProcess().accept(this, instance);
88		} catch (AwaitMessageException e) {
89	0	e.printStackTrace();
90		} catch (Exception e) {
91	0	e.printStackTrace();
92		}
93		}
94
95		//**************************************************/
96		// process the Process
97		//**************************************************/
98
99	4	public void process(Process process, ProcessInstance instance)
100		throws Exception {
101
102	4	log.info("Processing a Process");
103
104		// process all child elements
105	4	Variables variables = process.getVariables();
106	4	if (variables != null) {
107	4	variables.accept(this, instance);
108		}
109
110	4	PartnerLinks partnerLinks = process.getPartnerLinks();
111	4	if (partnerLinks != null) {
112	4	partnerLinks.accept(this, instance);
113		}
114
115	4	Activity activity = process.getActivity();
116		// there must be one root activity of this process
117	4	if (activity != null) {
118	4	activity.accept(this, instance);
119		} else {
120	0	throw new MissingActivityException();
121		}
122		}
123
124		//**************************************************/
125		// process structured activities
126		//**************************************************/
127
128	4	public void process(Sequence sequence, ProcessInstance instance)
129		throws Exception {
130
131	4	log(sequence);
132
133		// process all activities in sequence
134	4	List activities = sequence.getActivities();
135	4	for (Iterator iter = activities.iterator(); iter.hasNext();) {
136	18	Activity activity = (Activity) iter.next();
137	18	activity.accept(this, instance);
138		}
139		}
140
141		/**
142		* This is the implementation of the Flow activity which is used for
143		* parallel execution. In this primitive implementation we don't use any
144		* thread pooling mechanisms. In a more sophisticated version of the
145		* ProcessController, we might make use of the
146		* http://jakarta.apache.org/commons/pool/ library for thread pooling.
147		*/
148	4	public void process(Flow flow, ProcessInstance instance) throws Exception {
149
150	4	log(flow);
151
152	4	List activities = flow.getActivities();
153	4	int activitiesCount = activities.size();
154	4	Thread[] flowThreads = new Thread[activitiesCount];
155
156		// execute activities in separate threads
157		// for parallelity
158		//
159	4	for (int i = 0; i < activitiesCount; i++) {
160	8	Activity activity = (Activity) activities.get(i);
161	8	flowThreads[i] = new FlowThread(this, instance, activity);
162	8	flowThreads[i].start();
163		}
164
165		// wait for termination of all started FlowThreads
166	4	for (int i = 0; i < flowThreads.length; i++) {
167	8	flowThreads[i].join();
168		}
169
170		/**
171		* TODO because the run() Thread method is not allowed to throw
172		* Exceptions, it is necessary to check the status of each executed
173		* Thread in order to know wheter it finished its taks correctly or
174		* failed.
175		*/
176		}
177
178		/**
179		* A default implementation of the
180		* <code>process(Switch, ProcessInstance)</code> method.
181		*
182		*/
183	0	public void process(Switch bpelSwitch, ProcessInstance instance)
184		throws Exception {
185
186	0	List bpelCases = bpelSwitch.getCases();
187	0	for (Iterator iter = bpelCases.iterator(); iter.hasNext();) {
188	0	BpelCase bpelCase = (BpelCase) iter.next();
189	0	if (bpelCase.getBooleanExpression().evaluate()) {
190	0	bpelCase.getCaseActivity().accept(this, instance);
191	0	return;
192		}
193		}
194
195	0	Activity otherwise = bpelSwitch.getOtherwise();
196	0	if (otherwise != null) {
197	0	otherwise.accept(this, instance);
198		}
199		}
200
201		//**************************************************/
202		// process atomic activities
203		//**************************************************/
204
205	4	public void process(Receive receive, ProcessInstance instance)
206		throws AwaitMessageException {
207
208	4	log(receive);
209
210		// get process context
211	4	ProcessContext ctx = instance.getContext();
212	4	BPELProcess process = instance.getProcess();
213
214	4	Event event = ctx.getEvent(receive);
215	4	if (event == null) {
216
217	4	BexeeMessage message = ctx.removeMessage();
218
219	4	if (message == null) {
220	0	throw new AwaitMessageException(receive);
221		} else {
222	4	event = new Event(receive);
223
224		// copy received value into context
225	4	Variable var = receive.getVariable();
226	4	ctx.setVariable(var, message.getParts());
227
228	4	ctx.addEvent(event);
229		}
230		}
231		}
232
233	6	public void process(Assign assign, ProcessInstance instance)
234		throws Exception {
235
236	6	log(assign);
237
238	6	BPELProcess process = instance.getProcess();
239	6	ProcessContext ctx = instance.getContext();
240
241	6	Event event = ctx.getEvent(assign);
242	6	if (event == null) {
243
244		// event creation
245	6	event = new Event(assign);
246
247		// get the copy of this assign
248	6	Copy copy = assign.getCopy();
249
250		// get from information
251	6	From from = copy.getFrom();
252	6	Variable fromVar = from.getVariable();
253	6	String fromVarPart = from.getPart();
254
255		// get to information
256	6	To to = copy.getTo();
257	6	Variable toVar = to.getVariable();
258	6	String toVarPart = to.getPart();
259
260		// get the from variable part and assign it
261	6	Object variablePart = ctx.getVariablePart(fromVar, fromVarPart);
262
263		// this is some magic just for demonstration purposes
264		//
265	6	String responseString = "";
266
267	6	if (assign.getName() != null
268		&& assign.getName().indexOf("Response") != -1) {
269	2	Collection varIds = ctx.getVariablesIdentifiers();
270	2	for (Iterator iter = varIds.iterator(); iter.hasNext();) {
271	6	Variable variable = (Variable) iter.next();
272	6	Collection parts = ctx.getVariable(variable).values();
273	6	for (Iterator iterator = parts.iterator(); iterator
274		.hasNext();) {
275	6	Object element = (Object) iterator.next();
276	6	if (element != null) {
277	6	responseString += "} {" + element.toString();
278		}
279		}
280		}
281	2	variablePart = responseString;
282		}
283
284	6	ctx.setVariablePart(toVar, toVarPart, variablePart);
285	6	ctx.addEvent(event);
286		}
287		}
288
289	8	public void process(Invoke invoke, ProcessInstance instance)
290		throws Exception {
291
292	8	log(invoke);
293
294		// initialize objects
295		//
296	8	ProcessContext ctx = instance.getContext();
297	8	BPELProcess process = instance.getProcess();
298
299	8	Event event = ctx.getEvent(invoke);
300	8	if (event == null) {
301
302		// event creation
303	8	event = new Event(invoke);
304
305		// get in variable value
306	8	Variable inVar = invoke.getInputVariable();
307	8	Map inVarParts = ctx.getVariable(inVar);
308	8	Object[] variablePartsAsArray = inVarParts.values().toArray();
309
310		// get out variable value
311	8	Variable outVar = invoke.getOutputVariable();
312	8	Map outVarParts = ctx.getVariable(outVar);
313
314		// get infos about the web service to be invoked
315	8	String operationName = invoke.getOperation();
316	8	QName portTypeName = invoke.getPortType();
317
318		// traverse definition in order to find information about the call
319	8	Definition definition = findWSDL(portTypeName, process);
320	8	PortType portType = definition.getPortType(portTypeName);
321	8	Operation operationType = portType.getOperation(operationName,
322		null, null);
323	8	Message inMessage = operationType.getInput().getMessage();
324	8	Object[] messageParts = inMessage.getParts().values().toArray();
325
326	8	Binding binding = findBinding(definition, portTypeName);
327	8	Port port = findPort(definition, binding);
328	8	SOAPAddress soapAddress = findSOAPAddress(port);
329
330		// build service call
331	8	Service service = new Service();
332	8	Call call = (Call) service.createCall();
333	8	call.setTargetEndpointAddress(soapAddress.getLocationURI());
334	8	call.setPortName(invoke.getPortType());
335	8	call.setOperationName(invoke.getOperation());
336
337		// add parameters to the call
338	8	for (int i = 0; i < messageParts.length; i++) {
339	8	Part messagePart = (Part) messageParts[i];
340	8	call.addParameter(messagePart.getName(), messagePart
341		.getTypeName(), ParameterMode.IN);
342		}
343	8	call.setReturnType(Constants.XSD_STRING);
344
345		// this will be the result of the invoke
346	8	Object result = null;
347
348		// call synchronously
349	8	if (invoke.isSynchronous()) {
350	8	result = call.invoke(variablePartsAsArray);
351		}
352		// call asynchronously
353		else {
354		// TODO asynchronous call in new thread
355		}
356
357		// assign result to the variable
358	0	Variable variable = invoke.getOutputVariable();
359	0	Message outMessage = operationType.getOutput().getMessage();
360	0	Object[] outparts = outMessage.getParts().values().toArray();
361	0	for (int i = 0; i < outparts.length; i++) {
362	0	Part messagePart = (Part) messageParts[i];
363	0	ctx.setVariablePart(variable, messagePart.getName(), result);
364		}
365
366	0	ctx.addEvent(event);
367		}
368		}
369
370	8	private Definition findWSDL(QName portTypeName, BPELProcess process) {
371
372	8	Definition definition = null;
373	8	Binding binding = null;
374
375		// find the right binding for the portType
376		//
377	8	Collection wsdlCollection = process.getPartnerWSDL();
378	8	mainloop: for (Iterator iter = wsdlCollection.iterator(); iter
379		.hasNext();) {
380	8	definition = (Definition) iter.next();
381	8	Collection bindings = definition.getBindings().values();
382	8	for (Iterator iterator = bindings.iterator(); iterator.hasNext();) {
383	8	binding = (Binding) iterator.next();
384	8	if (binding.getPortType().getQName().equals(portTypeName)) {
385	8	break mainloop;
386		}
387		}
388		}
389	8	return definition;
390		}
391
392	8	private Binding findBinding(Definition definition, QName portTypeName) {
393
394	8	Binding binding = null;
395
396	8	Collection bindings = definition.getBindings().values();
397	8	for (Iterator iterator = bindings.iterator(); iterator.hasNext();) {
398	8	binding = (Binding) iterator.next();
399	8	if (binding.getPortType().getQName().equals(portTypeName)) {