001: /*
002: * Portions Copyright 2006 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025:
026: package com.sun.xml.internal.ws.wsdl.parser;
027:
028: import com.sun.xml.internal.ws.model.ParameterBinding;
029: import com.sun.xml.internal.ws.server.DocInfo;
030: import com.sun.xml.internal.ws.server.DocInfo.DOC_TYPE;
031: import com.sun.xml.internal.ws.streaming.XMLStreamReaderFactory;
032: import com.sun.xml.internal.ws.streaming.XMLStreamReaderUtil;
033: import com.sun.xml.internal.ws.streaming.TidyXMLStreamReader;
034: import com.sun.xml.internal.ws.util.xml.XmlUtil;
035: import org.xml.sax.EntityResolver;
036: import org.xml.sax.InputSource;
037: import org.xml.sax.SAXException;
038:
039: import javax.xml.namespace.QName;
040: import javax.xml.stream.XMLStreamConstants;
041: import javax.xml.stream.XMLStreamException;
042: import javax.xml.stream.XMLStreamReader;
043: import javax.xml.ws.soap.SOAPBinding;
044: import javax.xml.ws.WebServiceException;
045: import java.io.IOException;
046: import java.io.InputStream;
047: import java.io.Reader;
048: import java.net.URL;
049: import java.util.List;
050: import java.util.Map;
051: import java.util.Set;
052: import java.util.HashSet;
053:
054: public class RuntimeWSDLParser {
055: private final WSDLDocument wsdlDoc = new WSDLDocument();
056: /**
057: * Target namespace URI of the WSDL that we are currently parsing.
058: */
059: private String targetNamespace;
060: /**
061: * System IDs of WSDLs that are already read.
062: */
063: private final Set<String> importedWSDLs = new HashSet<String>();
064: /**
065: * Must not be null.
066: */
067: private final EntityResolver resolver;
068:
069: public static WSDLDocument parse(URL wsdlLoc,
070: EntityResolver resolver) throws IOException,
071: XMLStreamException, SAXException {
072: assert resolver != null;
073: RuntimeWSDLParser parser = new RuntimeWSDLParser(resolver);
074: parser.parseWSDL(wsdlLoc);
075: return parser.wsdlDoc;
076: }
077:
078: /*
079: * Fills DocInfo with Document type(WSDL, or schema),
080: * Service Name, Port Type name, targetNamespace for the document.
081: *
082: * Don't follow imports
083: */
084: public static void fillDocInfo(DocInfo docInfo, QName serviceName,
085: QName portTypeName) throws XMLStreamException {
086:
087: RuntimeWSDLParser parser = new RuntimeWSDLParser(null);
088: InputSource source = new InputSource(docInfo.getDoc());
089:
090: XMLStreamReader reader = createReader(source);
091: try {
092: XMLStreamReaderUtil.nextElementContent(reader);
093:
094: if (reader.getName().equals(WSDLConstants.QNAME_SCHEMA)) {
095: docInfo.setDocType(DOC_TYPE.SCHEMA);
096: String tns = ParserUtil.getMandatoryNonEmptyAttribute(
097: reader, WSDLConstants.ATTR_TNS);
098: docInfo.setTargetNamespace(tns);
099: return;
100: } else if (reader.getName().equals(
101: WSDLConstants.QNAME_DEFINITIONS)) {
102: docInfo.setDocType(DOC_TYPE.WSDL);
103: String tns = ParserUtil.getMandatoryNonEmptyAttribute(
104: reader, WSDLConstants.ATTR_TNS);
105: parser.targetNamespace = tns;
106: docInfo.setTargetNamespace(tns);
107: } else {
108: docInfo.setDocType(DOC_TYPE.OTHER);
109: return;
110: }
111:
112: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
113: if (reader.getEventType() == XMLStreamConstants.END_DOCUMENT)
114: break;
115:
116: QName name = reader.getName();
117: if (WSDLConstants.QNAME_PORT_TYPE.equals(name)) {
118: String pn = ParserUtil
119: .getMandatoryNonEmptyAttribute(reader,
120: WSDLConstants.ATTR_NAME);
121: if (portTypeName != null) {
122: if (portTypeName.getLocalPart().equals(pn)
123: && portTypeName
124: .getNamespaceURI()
125: .equals(
126: docInfo
127: .getTargetNamespace())) {
128: docInfo.setHavingPortType(true);
129: }
130: }
131: XMLStreamReaderUtil.skipElement(reader);
132: } else if (WSDLConstants.QNAME_SERVICE.equals(name)) {
133: String sn = ParserUtil
134: .getMandatoryNonEmptyAttribute(reader,
135: WSDLConstants.ATTR_NAME);
136: QName sqn = new QName(docInfo.getTargetNamespace(),
137: sn);
138: if (serviceName.equals(sqn)) {
139: parser.parseService(reader);
140: docInfo.setService(parser.wsdlDoc
141: .getService(sqn));
142: if (reader.getEventType() != XMLStreamConstants.END_ELEMENT)
143: XMLStreamReaderUtil.next(reader);
144: } else {
145: XMLStreamReaderUtil.skipElement(reader);
146: }
147: } else {
148: XMLStreamReaderUtil.skipElement(reader);
149: }
150: }
151: } finally {
152: reader.close();
153: }
154: }
155:
156: private RuntimeWSDLParser(EntityResolver resolver) {
157: this .resolver = resolver;
158: }
159:
160: /**
161: * Make sure to return a "fresh" reader each time it is called because
162: * more than one active reader may be needed within a single thread
163: * to parse a WSDL file.
164: */
165: private static XMLStreamReader createReader(InputSource source) {
166: // Char stream available?
167: if (source.getCharacterStream() != null) {
168: Reader reader = source.getCharacterStream();
169: return new TidyXMLStreamReader(XMLStreamReaderFactory
170: .createFreshXMLStreamReader(source.getSystemId(),
171: reader), reader);
172: }
173:
174: // Byte stream available?
175: if (source.getByteStream() != null) {
176: InputStream stream = source.getByteStream();
177: return new TidyXMLStreamReader(XMLStreamReaderFactory
178: .createFreshXMLStreamReader(source.getSystemId(),
179: stream), stream);
180: }
181:
182: // Otherwise, open URI
183: try {
184: InputStream stream = new URL(source.getSystemId())
185: .openStream();
186: return new TidyXMLStreamReader(XMLStreamReaderFactory
187: .createFreshXMLStreamReader(source.getSystemId(),
188: stream), stream);
189: } catch (IOException e) {
190: throw new WebServiceException(e);
191: }
192: }
193:
194: private void parseWSDL(URL wsdlLoc) throws XMLStreamException,
195: IOException, SAXException {
196:
197: // String systemId = wsdlLoc.toExternalForm();
198: // InputSource source = resolver.resolveEntity(null,systemId);
199: // if(source==null)
200: // source = new InputSource(systemId);
201:
202: InputSource source = resolver.resolveEntity(null, wsdlLoc
203: .toExternalForm());
204: if (source == null)
205: source = new InputSource(wsdlLoc.toExternalForm()); // default resolution
206: else if (source.getSystemId() == null)
207: // ideally entity resolvers should be giving us the system ID for the resource
208: // (or otherwise we won't be able to resolve references within this imported WSDL correctly),
209: // but if none is given, the system ID before the entity resolution is better than nothing.
210: source.setSystemId(wsdlLoc.toExternalForm());
211:
212: // avoid processing the same WSDL twice.
213: if (!importedWSDLs.add(source.getSystemId()))
214: return;
215:
216: XMLStreamReader reader = createReader(source);
217: XMLStreamReaderUtil.nextElementContent(reader);
218:
219: //wsdl:definition
220: if (!reader.getName().equals(WSDLConstants.QNAME_DEFINITIONS)) {
221: ParserUtil.failWithFullName(
222: "runtime.parser.wsdl.invalidElement", reader);
223: }
224:
225: //get the targetNamespace of the service
226: String tns = ParserUtil.getMandatoryNonEmptyAttribute(reader,
227: WSDLConstants.ATTR_TNS);
228:
229: final String oldTargetNamespace = targetNamespace;
230: targetNamespace = tns;
231:
232: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
233: if (reader.getEventType() == XMLStreamConstants.END_DOCUMENT)
234: break;
235:
236: QName name = reader.getName();
237: if (WSDLConstants.QNAME_IMPORT.equals(name)) {
238: parseImport(wsdlLoc, reader);
239: } else if (WSDLConstants.QNAME_MESSAGE.equals(name)) {
240: parseMessage(reader);
241: } else if (WSDLConstants.QNAME_PORT_TYPE.equals(name)) {
242: parsePortType(reader);
243: } else if (WSDLConstants.QNAME_BINDING.equals(name)) {
244: parseBinding(reader);
245: } else if (WSDLConstants.QNAME_SERVICE.equals(name)) {
246: parseService(reader);
247: } else {
248: XMLStreamReaderUtil.skipElement(reader);
249: }
250: }
251: targetNamespace = oldTargetNamespace;
252: reader.close();
253: }
254:
255: private void parseService(XMLStreamReader reader) {
256: String serviceName = ParserUtil.getMandatoryNonEmptyAttribute(
257: reader, WSDLConstants.ATTR_NAME);
258: Service service = new Service(new QName(targetNamespace,
259: serviceName));
260: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
261: QName name = reader.getName();
262: if (WSDLConstants.QNAME_PORT.equals(name)) {
263: parsePort(reader, service);
264: if (reader.getEventType() != XMLStreamConstants.END_ELEMENT)
265: XMLStreamReaderUtil.next(reader);
266: } else {
267: XMLStreamReaderUtil.skipElement(reader);
268: }
269: }
270: wsdlDoc.addService(service);
271: }
272:
273: private static void parsePort(XMLStreamReader reader,
274: Service service) {
275: String portName = ParserUtil.getMandatoryNonEmptyAttribute(
276: reader, WSDLConstants.ATTR_NAME);
277: String binding = ParserUtil.getMandatoryNonEmptyAttribute(
278: reader, "binding");
279: QName bindingName = ParserUtil.getQName(reader, binding);
280: String location = null;
281: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
282: QName name = reader.getName();
283: if (SOAPConstants.QNAME_ADDRESS.equals(name)
284: || SOAPConstants.QNAME_SOAP12ADDRESS.equals(name)) {
285: location = ParserUtil.getMandatoryNonEmptyAttribute(
286: reader, WSDLConstants.ATTR_LOCATION);
287: XMLStreamReaderUtil.next(reader);
288: } else {
289: XMLStreamReaderUtil.skipElement(reader);
290: }
291: }
292: QName portQName = new QName(
293: service.getName().getNamespaceURI(), portName);
294: service.put(portQName, new Port(portQName, bindingName,
295: location));
296: }
297:
298: private void parseBinding(XMLStreamReader reader) {
299: String bindingName = ParserUtil.getMandatoryNonEmptyAttribute(
300: reader, "name");
301: String portTypeName = ParserUtil.getMandatoryNonEmptyAttribute(
302: reader, "type");
303: if ((bindingName == null) || (portTypeName == null)) {
304: //TODO: throw exception?
305: //skip wsdl:binding element for now
306: XMLStreamReaderUtil.skipElement(reader);
307: return;
308: }
309: Binding binding = new Binding(new QName(targetNamespace,
310: bindingName), ParserUtil.getQName(reader, portTypeName));
311: binding.setWsdlDocument(wsdlDoc);
312: wsdlDoc.addBinding(binding);
313:
314: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
315: QName name = reader.getName();
316: if (WSDLConstants.NS_SOAP_BINDING.equals(name)) {
317: binding.setBindingId(SOAPBinding.SOAP11HTTP_BINDING);
318: XMLStreamReaderUtil.next(reader);
319: } else if (WSDLConstants.NS_SOAP12_BINDING.equals(name)) {
320: binding.setBindingId(SOAPBinding.SOAP12HTTP_BINDING);
321: XMLStreamReaderUtil.next(reader);
322: } else if (WSDLConstants.QNAME_OPERATION.equals(name)) {
323: parseBindingOperation(reader, binding);
324: } else {
325: XMLStreamReaderUtil.skipElement(reader);
326: }
327: }
328: }
329:
330: private static void parseBindingOperation(XMLStreamReader reader,
331: Binding binding) {
332: String bindingOpName = ParserUtil
333: .getMandatoryNonEmptyAttribute(reader, "name");
334: if (bindingOpName == null) {
335: //TODO: throw exception?
336: //skip wsdl:binding element for now
337: XMLStreamReaderUtil.skipElement(reader);
338: return;
339: }
340:
341: BindingOperation bindingOp = new BindingOperation(bindingOpName);
342: binding.put(bindingOpName, bindingOp);
343:
344: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
345: QName name = reader.getName();
346: if (WSDLConstants.QNAME_INPUT.equals(name)) {
347: parseInputBinding(reader, bindingOp);
348: } else if (WSDLConstants.QNAME_OUTPUT.equals(name)) {
349: parseOutputBinding(reader, bindingOp);
350: } else {
351: XMLStreamReaderUtil.skipElement(reader);
352: }
353: }
354: }
355:
356: private static void parseInputBinding(XMLStreamReader reader,
357: BindingOperation bindingOp) {
358: boolean bodyFound = false;
359: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
360: QName name = reader.getName();
361: if ((SOAPConstants.QNAME_BODY.equals(name) || SOAPConstants.QNAME_SOAP12BODY
362: .equals(name))
363: && !bodyFound) {
364: bodyFound = true;
365: bindingOp
366: .setInputExplicitBodyParts(parseSOAPBodyBinding(
367: reader, bindingOp, BindingMode.INPUT));
368: goToEnd(reader);
369: } else if ((SOAPConstants.QNAME_HEADER.equals(name) || SOAPConstants.QNAME_SOAP12HEADER
370: .equals(name))) {
371: parseSOAPHeaderBinding(reader, bindingOp
372: .getInputParts());
373: } else if (MIMEConstants.QNAME_MULTIPART_RELATED
374: .equals(name)) {
375: parseMimeMultipartBinding(reader, bindingOp,
376: BindingMode.INPUT);
377: } else {
378: XMLStreamReaderUtil.skipElement(reader);
379: }
380:
381: }
382: }
383:
384: private static void parseOutputBinding(XMLStreamReader reader,
385: BindingOperation bindingOp) {
386: boolean bodyFound = false;
387: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
388: QName name = reader.getName();
389: if ((SOAPConstants.QNAME_BODY.equals(name) || SOAPConstants.QNAME_SOAP12BODY
390: .equals(name))
391: && !bodyFound) {
392: bodyFound = true;
393: bindingOp
394: .setOutputExplicitBodyParts(parseSOAPBodyBinding(
395: reader, bindingOp, BindingMode.OUTPUT));
396: goToEnd(reader);
397: } else if ((SOAPConstants.QNAME_HEADER.equals(name) || SOAPConstants.QNAME_SOAP12HEADER
398: .equals(name))) {
399: parseSOAPHeaderBinding(reader, bindingOp
400: .getOutputParts());
401: } else if (MIMEConstants.QNAME_MULTIPART_RELATED
402: .equals(name)) {
403: parseMimeMultipartBinding(reader, bindingOp,
404: BindingMode.OUTPUT);
405: } else {
406: XMLStreamReaderUtil.skipElement(reader);
407: }
408:
409: }
410: }
411:
412: private static boolean parseSOAPBodyBinding(XMLStreamReader reader,
413: BindingOperation op, BindingMode mode) {
414: String namespace = reader.getAttributeValue(null, "namespace");
415: if (mode == BindingMode.INPUT) {
416: op.reqNamespace = namespace;
417: return parseSOAPBodyBinding(reader, op.getInputParts());
418: }
419: //resp
420: op.respNamespace = namespace;
421: return parseSOAPBodyBinding(reader, op.getOutputParts());
422: }
423:
424: /**
425: * Returns true if body has explicit parts declaration
426: */
427: private static boolean parseSOAPBodyBinding(XMLStreamReader reader,
428: Map<String, ParameterBinding> parts) {
429: String partsString = reader.getAttributeValue(null, "parts");
430: if (partsString != null) {
431: List<String> partsList = XmlUtil
432: .parseTokenList(partsString);
433: if (partsList.isEmpty()) {
434: parts.put(" ", ParameterBinding.BODY);
435: } else {
436: for (String part : partsList) {
437: parts.put(part, ParameterBinding.BODY);
438: }
439: }
440: return true;
441: }
442: return false;
443: }
444:
445: private static void parseSOAPHeaderBinding(XMLStreamReader reader,
446: Map<String, ParameterBinding> parts) {
447: String part = reader.getAttributeValue(null, "part");
448: //if(part == null| part.equals("")||message == null || message.equals("")){
449: if (part == null | part.equals("")) {
450: return;
451: }
452:
453: //lets not worry about message attribute for now, probably additional headers wont be there
454: //String message = reader.getAttributeValue(null, "message");
455: //QName msgName = ParserUtil.getQName(reader, message);
456: parts.put(part, ParameterBinding.HEADER);
457: goToEnd(reader);
458: }
459:
460: private enum BindingMode {
461: INPUT, OUTPUT
462: };
463:
464: private static void parseMimeMultipartBinding(
465: XMLStreamReader reader, BindingOperation op,
466: BindingMode mode) {
467: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
468: QName name = reader.getName();
469: if (MIMEConstants.QNAME_PART.equals(name)) {
470: parseMIMEPart(reader, op, mode);
471: } else {
472: XMLStreamReaderUtil.skipElement(reader);
473: }
474: }
475:
476: }
477:
478: private static void parseMIMEPart(XMLStreamReader reader,
479: BindingOperation op, BindingMode mode) {
480: boolean bodyFound = false;
481: Map<String, ParameterBinding> parts = null;
482: Map<String, String> mimeTypes = null;
483: if (mode == BindingMode.INPUT) {
484: parts = op.getInputParts();
485: mimeTypes = op.getInputMimeTypes();
486: } else {
487: parts = op.getOutputParts();
488: mimeTypes = op.getOutputMimeTypes();
489: }
490:
491: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
492: QName name = reader.getName();
493: if (SOAPConstants.QNAME_BODY.equals(name) && !bodyFound) {
494: bodyFound = true;
495: parseSOAPBodyBinding(reader, op, mode);
496: XMLStreamReaderUtil.next(reader);
497: } else if (SOAPConstants.QNAME_HEADER.equals(name)) {
498: bodyFound = true;
499: parseSOAPHeaderBinding(reader, parts);
500: XMLStreamReaderUtil.next(reader);
501: } else if (MIMEConstants.QNAME_CONTENT.equals(name)) {
502: String part = reader.getAttributeValue(null, "part");
503: String type = reader.getAttributeValue(null, "type");
504: if ((part == null) || (type == null)) {
505: XMLStreamReaderUtil.skipElement(reader);
506: continue;
507: }
508: ParameterBinding sb = ParameterBinding
509: .createAttachment(type);
510: parts.put(part, sb);
511: //mimeTypes.put(part, type);
512: XMLStreamReaderUtil.next(reader);
513: } else {
514: XMLStreamReaderUtil.skipElement(reader);
515: }
516: }
517: }
518:
519: protected void parseImport(URL baseURL, XMLStreamReader reader)
520: throws IOException, SAXException, XMLStreamException {
521: // expand to the absolute URL of the imported WSDL.
522: String importLocation = ParserUtil
523: .getMandatoryNonEmptyAttribute(reader,
524: WSDLConstants.ATTR_LOCATION);
525: URL importURL = new URL(baseURL, importLocation);
526: parseWSDL(importURL);
527: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
528: XMLStreamReaderUtil.skipElement(reader);
529: }
530: }
531:
532: private void parsePortType(XMLStreamReader reader) {
533: String portTypeName = ParserUtil.getMandatoryNonEmptyAttribute(
534: reader, WSDLConstants.ATTR_NAME);
535: if (portTypeName == null) {
536: //TODO: throw exception?
537: //skip wsdl:portType element for now
538: XMLStreamReaderUtil.skipElement(reader);
539: return;
540: }
541: PortType portType = new PortType(new QName(targetNamespace,
542: portTypeName));
543: wsdlDoc.addPortType(portType);
544: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
545: QName name = reader.getName();
546: if (WSDLConstants.QNAME_OPERATION.equals(name)) {
547: parsePortTypeOperation(reader, portType);
548: } else {
549: XMLStreamReaderUtil.skipElement(reader);
550: }
551: }
552: }
553:
554: private void parsePortTypeOperation(XMLStreamReader reader,
555: PortType portType) {
556: String operationName = ParserUtil
557: .getMandatoryNonEmptyAttribute(reader,
558: WSDLConstants.ATTR_NAME);
559: if (operationName == null) {
560: //TODO: throw exception?
561: //skip wsdl:portType element for now
562: XMLStreamReaderUtil.skipElement(reader);
563: return;
564: }
565:
566: QName operationQName = new QName(portType.getName()
567: .getNamespaceURI(), operationName);
568: PortTypeOperation operation = new PortTypeOperation(
569: operationQName);
570: String parameterOrder = ParserUtil.getAttribute(reader,
571: "parameterOrder");
572: operation.setParameterOrder(parameterOrder);
573: portType.put(operationName, operation);
574: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
575: QName name = reader.getName();
576: if (name.equals(WSDLConstants.QNAME_INPUT)) {
577: parsePortTypeOperationInput(reader, operation);
578: } else if (name.equals(WSDLConstants.QNAME_OUTPUT)) {
579: parsePortTypeOperationOutput(reader, operation);
580: } else {
581: XMLStreamReaderUtil.skipElement(reader);
582: }
583: }
584: }
585:
586: private void parsePortTypeOperationInput(XMLStreamReader reader,
587: PortTypeOperation operation) {
588: String msg = ParserUtil.getAttribute(reader, "message");
589: QName msgName = ParserUtil.getQName(reader, msg);
590: operation.setInputMessage(msgName);
591: goToEnd(reader);
592: }
593:
594: private void parsePortTypeOperationOutput(XMLStreamReader reader,
595: PortTypeOperation operation) {
596: String msg = ParserUtil.getAttribute(reader, "message");
597: QName msgName = ParserUtil.getQName(reader, msg);
598: operation.setOutputMessage(msgName);
599: goToEnd(reader);
600: }
601:
602: private void parseMessage(XMLStreamReader reader) {
603: String msgName = ParserUtil.getMandatoryNonEmptyAttribute(
604: reader, WSDLConstants.ATTR_NAME);
605: Message msg = new Message(new QName(targetNamespace, msgName));
606: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
607: QName name = reader.getName();
608: if (WSDLConstants.QNAME_PART.equals(name)) {
609: String part = ParserUtil.getMandatoryNonEmptyAttribute(
610: reader, WSDLConstants.ATTR_NAME);
611: // String desc = null;
612: // int index = reader.getAttributeCount();
613: // for (int i = 0; i < index; i++) {
614: // if (reader.getAttributeName(i).equals("element") || reader.getAttributeName(i).equals("type")) {
615: // desc = reader.getAttributeValue(i);
616: // break;
617: // }
618: // }
619: // if (desc == null)
620: // continue;
621: msg.add(part);
622: if (reader.getEventType() != XMLStreamConstants.END_ELEMENT)
623: goToEnd(reader);
624: } else {
625: XMLStreamReaderUtil.skipElement(reader);
626: }
627: }
628: wsdlDoc.addMessage(msg);
629: if (reader.getEventType() != XMLStreamConstants.END_ELEMENT)
630: goToEnd(reader);
631: }
632:
633: private static void goToEnd(XMLStreamReader reader) {
634: while (XMLStreamReaderUtil.nextElementContent(reader) != XMLStreamConstants.END_ELEMENT) {
635: XMLStreamReaderUtil.skipElement(reader);
636: }
637: }
638:
639: }
|