< prev index next >

src/java.xml.ws/share/classes/com/sun/xml/internal/messaging/saaj/soap/impl/EnvelopeImpl.java

Print this page




  83         this(ownerDoc, name);
  84 
  85         ensureNamespaceIsDeclared(
  86             getElementQName().getPrefix(), getElementQName().getNamespaceURI());
  87 
  88         // XXX
  89         if (createHeader)
  90             addHeader();
  91 
  92         if (createBody)
  93             addBody();
  94     }
  95 
  96     public EnvelopeImpl(SOAPDocumentImpl ownerDoc, Element domElement) {
  97         super(ownerDoc, domElement);
  98     }
  99 
 100     protected abstract NameImpl getHeaderName(String prefix);
 101     protected abstract NameImpl getBodyName(String prefix);
 102 

 103     public SOAPHeader addHeader() throws SOAPException {
 104         return addHeader(null);
 105     }
 106 
 107     public SOAPHeader addHeader(String prefix) throws SOAPException {
 108 
 109         if (prefix == null || prefix.equals("")) {
 110             prefix = getPrefix();
 111         }
 112 
 113         NameImpl headerName = getHeaderName(prefix);
 114         NameImpl bodyName = getBodyName(prefix);
 115 
 116         HeaderImpl header = null;
 117         SOAPElement firstChild = (SOAPElement) getFirstChildElement();
 118 
 119         if (firstChild != null) {
 120             if (firstChild.getElementName().equals(headerName)) {
 121                 log.severe("SAAJ0120.impl.header.already.exists");
 122                 throw new SOAPExceptionImpl("Can't add a header when one is already present.");
 123             } else if (!firstChild.getElementName().equals(bodyName)) {
 124                 log.severe("SAAJ0121.impl.invalid.first.child.of.envelope");
 125                 throw new SOAPExceptionImpl("First child of Envelope must be either a Header or Body");
 126             }
 127         }
 128 
 129         header = (HeaderImpl) createElement(headerName);
 130         insertBefore(header.getDomElement(), firstChild);
 131         header.ensureNamespaceIsDeclared(headerName.getPrefix(), headerName.getURI());
 132 
 133         return header;
 134     }
 135 
 136     protected void lookForHeader() throws SOAPException {
 137         NameImpl headerName = getHeaderName(null);
 138 
 139         HeaderImpl hdr = (HeaderImpl) findChild(headerName);
 140         header = hdr;
 141     }
 142 

 143     public SOAPHeader getHeader() throws SOAPException {
 144         lookForHeader();
 145         return header;
 146     }
 147 
 148     protected void lookForBody() throws SOAPException {
 149         NameImpl bodyName = getBodyName(null);
 150 
 151         BodyImpl bodyChildElement = (BodyImpl) findChild(bodyName);
 152         body = bodyChildElement;
 153     }
 154 

 155     public SOAPBody addBody() throws SOAPException {
 156         return addBody(null);
 157     }
 158 
 159     public SOAPBody addBody(String prefix) throws SOAPException {
 160         lookForBody();
 161 
 162         if (prefix == null || prefix.equals("")) {
 163             prefix = getPrefix();
 164         }
 165 
 166         if (body == null) {
 167             NameImpl bodyName = getBodyName(prefix);
 168             body = (BodyImpl) createElement(bodyName);
 169             insertBefore(body.getDomElement(), null);
 170             body.ensureNamespaceIsDeclared(bodyName.getPrefix(), bodyName.getURI());
 171         } else {
 172             log.severe("SAAJ0122.impl.body.already.exists");
 173             throw new SOAPExceptionImpl("Can't add a body when one is already present.");
 174         }
 175 
 176         return body;
 177     }
 178 

 179     protected SOAPElement addElement(Name name) throws SOAPException {
 180         if (getBodyName(null).equals(name)) {
 181             return addBody(name.getPrefix());
 182         }
 183         if (getHeaderName(null).equals(name)) {
 184             return addHeader(name.getPrefix());
 185         }
 186 
 187         return super.addElement(name);
 188     }
 189 

 190     protected SOAPElement addElement(QName name) throws SOAPException {
 191         if (getBodyName(null).equals(NameImpl.convertToName(name))) {
 192             return addBody(name.getPrefix());
 193         }
 194         if (getHeaderName(null).equals(NameImpl.convertToName(name))) {
 195             return addHeader(name.getPrefix());
 196         }
 197 
 198         return super.addElement(name);
 199     }
 200 

 201     public SOAPBody getBody() throws SOAPException {
 202         lookForBody();
 203         return body;
 204     }
 205 

 206     public Source getContent() {
 207         return new DOMSource(getOwnerDocument());
 208     }
 209 

 210     public Name createName(String localName, String prefix, String uri)
 211         throws SOAPException {
 212 
 213         // validating parameters before passing them on
 214         // to make sure that the namespace specification rules are followed
 215 
 216         // reserved xmlns prefix cannot be used.
 217         if ("xmlns".equals(prefix)) {
 218             log.severe("SAAJ0123.impl.no.reserved.xmlns");
 219             throw new SOAPExceptionImpl("Cannot declare reserved xmlns prefix");
 220         }
 221         // Qualified name cannot be xmlns.
 222         if ((prefix == null) && ("xmlns".equals(localName))) {
 223             log.severe("SAAJ0124.impl.qualified.name.cannot.be.xmlns");
 224             throw new SOAPExceptionImpl("Qualified name cannot be xmlns");
 225         }
 226 
 227         return NameImpl.create(localName, prefix, uri);
 228     }
 229 
 230     public Name createName(String localName, String prefix)
 231         throws SOAPException {
 232         String namespace = getNamespaceURI(prefix);
 233         if (namespace == null) {
 234             log.log(
 235                 Level.SEVERE,
 236                 "SAAJ0126.impl.cannot.locate.ns",
 237                 new String[] { prefix });
 238             throw new SOAPExceptionImpl(
 239                 "Unable to locate namespace for prefix " + prefix);
 240         }
 241         return NameImpl.create(localName, prefix, namespace);
 242     }
 243 

 244     public Name createName(String localName) throws SOAPException {
 245         return NameImpl.createFromUnqualifiedName(localName);
 246     }
 247 
 248     public void setOmitXmlDecl(String value) {
 249         this.omitXmlDecl = value;
 250     }
 251 
 252     public void setXmlDecl(String value) {
 253         this.xmlDecl = value;
 254     }
 255 
 256     public void setCharsetEncoding(String value) {
 257         charset = value;
 258     }
 259 

 260     public void output(OutputStream out) throws IOException {
 261         try {
 262 //            materializeBody();
 263             Transformer transformer =
 264                 EfficientStreamingTransformer.newTransformer();
 265 
 266             transformer.setOutputProperty(
 267                 OutputKeys.OMIT_XML_DECLARATION, "yes");
 268                 /*omitXmlDecl);*/
 269             // no equivalent for "setExpandEmptyElements"
 270             transformer.setOutputProperty(
 271                 OutputKeys.ENCODING,
 272                 charset);
 273 
 274             if (omitXmlDecl.equals("no") && xmlDecl == null) {
 275                 xmlDecl = "<?xml version=\"" + getOwnerDocument().getXmlVersion() + "\" encoding=\"" +
 276                     charset + "\" ?>";
 277             }
 278 
 279            StreamResult result = new StreamResult(out);


 284                 result = new StreamResult(writer);
 285             }
 286 
 287             if (log.isLoggable(Level.FINE)) {
 288                 log.log(Level.FINE, "SAAJ0190.impl.set.xml.declaration",
 289                         new String[] { omitXmlDecl });
 290                 log.log(Level.FINE, "SAAJ0191.impl.set.encoding",
 291                         new String[] { charset });
 292             }
 293 
 294             //StreamResult result = new StreamResult(out);
 295             transformer.transform(getContent(), result);
 296         } catch (Exception ex) {
 297             throw new IOException(ex.getMessage());
 298         }
 299     }
 300 
 301     /**
 302      * Serialize to FI if boolean parameter set.
 303      */

 304     public void output(OutputStream out, boolean isFastInfoset)
 305         throws IOException
 306     {
 307         if (!isFastInfoset) {
 308             output(out);
 309         }
 310         else {
 311             try {
 312                 // Run transform and generate FI output from content
 313                 Transformer transformer = EfficientStreamingTransformer.newTransformer();
 314                     transformer.transform(getContent(),
 315                         FastInfosetReflection.FastInfosetResult_new(out));
 316             }
 317             catch (Exception ex) {
 318                 throw new IOException(ex.getMessage());
 319             }
 320         }
 321     }
 322 
 323     //    public void prettyPrint(OutputStream out) throws IOException {


 336     //        writer.write(getDocument());
 337     //    }
 338     //
 339     //    public void prettyPrint(Writer out) throws IOException {
 340     //        if (getDocument() == null)
 341     //            initDocument();
 342     //
 343     //        OutputFormat format = OutputFormat.createPrettyPrint();
 344     //
 345     //        format.setIndentSize(2);
 346     //        format.setNewlines(true);
 347     //        format.setTrimText(true);
 348     //        format.setPadText(true);
 349     //        format.setExpandEmptyElements(false);
 350     //
 351     //        XMLWriter writer = new XMLWriter(out, format);
 352     //        writer.write(getDocument());
 353     //    }
 354 
 355 

 356      public SOAPElement setElementQName(QName newName) throws SOAPException {
 357         log.log(Level.SEVERE,
 358                 "SAAJ0146.impl.invalid.name.change.requested",
 359                 new Object[] {elementQName.getLocalPart(),
 360                               newName.getLocalPart()});
 361         throw new SOAPException("Cannot change name for "
 362                                 + elementQName.getLocalPart() + " to "
 363                                 + newName.getLocalPart());
 364      }
 365 
 366     @Override
 367     public void setStaxBridge(StaxBridge bridge) throws SOAPException {
 368         //set it on the body
 369         ((BodyImpl) getBody()).setStaxBridge(bridge);
 370     }
 371 
 372     @Override
 373     public StaxBridge getStaxBridge() throws SOAPException {
 374         return ((BodyImpl) getBody()).getStaxBridge();
 375     }
 376 
 377     @Override
 378     public XMLStreamReader getPayloadReader() throws SOAPException {
 379         return ((BodyImpl) getBody()).getPayloadReader();
 380     }
 381 
 382     @Override
 383     public void writeTo(final XMLStreamWriter writer) throws XMLStreamException, SOAPException {
 384         StaxBridge readBridge = this.getStaxBridge();
 385         if (readBridge != null && readBridge instanceof StaxLazySourceBridge) {
 386 //              StaxSoapWriteBridge writingBridge =  new StaxSoapWriteBridge(this);
 387 //              writingBridge.write(writer);
 388                 final String soapEnvNS = this.getNamespaceURI();
 389                 final DOMStreamReader reader = new DOMStreamReader(this);
 390                 XMLStreamReaderToXMLStreamWriter writingBridge =  new XMLStreamReaderToXMLStreamWriter();
 391                 writingBridge.bridge( new XMLStreamReaderToXMLStreamWriter.Breakpoint(reader, writer) {

 392                         public boolean proceedAfterStartElement()  {
 393                                 if ("Body".equals(reader.getLocalName()) && soapEnvNS.equals(reader.getNamespaceURI()) ){
 394                                         return false;
 395                                 } else
 396                                         return true;
 397                         }
 398             });//bridgeToBodyStartTag
 399             ((StaxLazySourceBridge)readBridge).writePayloadTo(writer);
 400             writer.writeEndElement();//body
 401             writer.writeEndElement();//env
 402             writer.writeEndDocument();
 403             writer.flush();
 404         } else {
 405                 LazyEnvelopeStaxReader lazyEnvReader = new LazyEnvelopeStaxReader(this);
 406                 XMLStreamReaderToXMLStreamWriter writingBridge = new XMLStreamReaderToXMLStreamWriter();
 407                 writingBridge.bridge(lazyEnvReader, writer);
 408 //            writingBridge.bridge(new XMLStreamReaderToXMLStreamWriter.Breakpoint(lazyEnvReader, writer));
 409         }
 410         //Assume the staxBridge is exhausted now since we would have read the body reader
 411         ((BodyImpl) getBody()).setPayloadStreamRead();




  83         this(ownerDoc, name);
  84 
  85         ensureNamespaceIsDeclared(
  86             getElementQName().getPrefix(), getElementQName().getNamespaceURI());
  87 
  88         // XXX
  89         if (createHeader)
  90             addHeader();
  91 
  92         if (createBody)
  93             addBody();
  94     }
  95 
  96     public EnvelopeImpl(SOAPDocumentImpl ownerDoc, Element domElement) {
  97         super(ownerDoc, domElement);
  98     }
  99 
 100     protected abstract NameImpl getHeaderName(String prefix);
 101     protected abstract NameImpl getBodyName(String prefix);
 102 
 103     @Override
 104     public SOAPHeader addHeader() throws SOAPException {
 105         return addHeader(null);
 106     }
 107 
 108     public SOAPHeader addHeader(String prefix) throws SOAPException {
 109 
 110         if (prefix == null || prefix.equals("")) {
 111             prefix = getPrefix();
 112         }
 113 
 114         NameImpl headerName = getHeaderName(prefix);
 115         NameImpl bodyName = getBodyName(prefix);
 116 
 117         HeaderImpl header = null;
 118         SOAPElement firstChild = (SOAPElement) getFirstChildElement();
 119 
 120         if (firstChild != null) {
 121             if (firstChild.getElementName().equals(headerName)) {
 122                 log.severe("SAAJ0120.impl.header.already.exists");
 123                 throw new SOAPExceptionImpl("Can't add a header when one is already present.");
 124             } else if (!firstChild.getElementName().equals(bodyName)) {
 125                 log.severe("SAAJ0121.impl.invalid.first.child.of.envelope");
 126                 throw new SOAPExceptionImpl("First child of Envelope must be either a Header or Body");
 127             }
 128         }
 129 
 130         header = (HeaderImpl) createElement(headerName);
 131         insertBefore(header.getDomElement(), firstChild);
 132         header.ensureNamespaceIsDeclared(headerName.getPrefix(), headerName.getURI());
 133 
 134         return header;
 135     }
 136 
 137     protected void lookForHeader() throws SOAPException {
 138         NameImpl headerName = getHeaderName(null);
 139 
 140         HeaderImpl hdr = (HeaderImpl) findChild(headerName);
 141         header = hdr;
 142     }
 143 
 144     @Override
 145     public SOAPHeader getHeader() throws SOAPException {
 146         lookForHeader();
 147         return header;
 148     }
 149 
 150     protected void lookForBody() throws SOAPException {
 151         NameImpl bodyName = getBodyName(null);
 152 
 153         BodyImpl bodyChildElement = (BodyImpl) findChild(bodyName);
 154         body = bodyChildElement;
 155     }
 156 
 157     @Override
 158     public SOAPBody addBody() throws SOAPException {
 159         return addBody(null);
 160     }
 161 
 162     public SOAPBody addBody(String prefix) throws SOAPException {
 163         lookForBody();
 164 
 165         if (prefix == null || prefix.equals("")) {
 166             prefix = getPrefix();
 167         }
 168 
 169         if (body == null) {
 170             NameImpl bodyName = getBodyName(prefix);
 171             body = (BodyImpl) createElement(bodyName);
 172             insertBefore(body.getDomElement(), null);
 173             body.ensureNamespaceIsDeclared(bodyName.getPrefix(), bodyName.getURI());
 174         } else {
 175             log.severe("SAAJ0122.impl.body.already.exists");
 176             throw new SOAPExceptionImpl("Can't add a body when one is already present.");
 177         }
 178 
 179         return body;
 180     }
 181 
 182     @Override
 183     protected SOAPElement addElement(Name name) throws SOAPException {
 184         if (getBodyName(null).equals(name)) {
 185             return addBody(name.getPrefix());
 186         }
 187         if (getHeaderName(null).equals(name)) {
 188             return addHeader(name.getPrefix());
 189         }
 190 
 191         return super.addElement(name);
 192     }
 193 
 194     @Override
 195     protected SOAPElement addElement(QName name) throws SOAPException {
 196         if (getBodyName(null).equals(NameImpl.convertToName(name))) {
 197             return addBody(name.getPrefix());
 198         }
 199         if (getHeaderName(null).equals(NameImpl.convertToName(name))) {
 200             return addHeader(name.getPrefix());
 201         }
 202 
 203         return super.addElement(name);
 204     }
 205 
 206     @Override
 207     public SOAPBody getBody() throws SOAPException {
 208         lookForBody();
 209         return body;
 210     }
 211 
 212     @Override
 213     public Source getContent() {
 214         return new DOMSource(getOwnerDocument());
 215     }
 216 
 217     @Override
 218     public Name createName(String localName, String prefix, String uri)
 219         throws SOAPException {
 220 
 221         // validating parameters before passing them on
 222         // to make sure that the namespace specification rules are followed
 223 
 224         // reserved xmlns prefix cannot be used.
 225         if ("xmlns".equals(prefix)) {
 226             log.severe("SAAJ0123.impl.no.reserved.xmlns");
 227             throw new SOAPExceptionImpl("Cannot declare reserved xmlns prefix");
 228         }
 229         // Qualified name cannot be xmlns.
 230         if ((prefix == null) && ("xmlns".equals(localName))) {
 231             log.severe("SAAJ0124.impl.qualified.name.cannot.be.xmlns");
 232             throw new SOAPExceptionImpl("Qualified name cannot be xmlns");
 233         }
 234 
 235         return NameImpl.create(localName, prefix, uri);
 236     }
 237 
 238     public Name createName(String localName, String prefix)
 239         throws SOAPException {
 240         String namespace = getNamespaceURI(prefix);
 241         if (namespace == null) {
 242             log.log(
 243                 Level.SEVERE,
 244                 "SAAJ0126.impl.cannot.locate.ns",
 245                 new String[] { prefix });
 246             throw new SOAPExceptionImpl(
 247                 "Unable to locate namespace for prefix " + prefix);
 248         }
 249         return NameImpl.create(localName, prefix, namespace);
 250     }
 251 
 252     @Override
 253     public Name createName(String localName) throws SOAPException {
 254         return NameImpl.createFromUnqualifiedName(localName);
 255     }
 256 
 257     public void setOmitXmlDecl(String value) {
 258         this.omitXmlDecl = value;
 259     }
 260 
 261     public void setXmlDecl(String value) {
 262         this.xmlDecl = value;
 263     }
 264 
 265     public void setCharsetEncoding(String value) {
 266         charset = value;
 267     }
 268 
 269     @Override
 270     public void output(OutputStream out) throws IOException {
 271         try {
 272 //            materializeBody();
 273             Transformer transformer =
 274                 EfficientStreamingTransformer.newTransformer();
 275 
 276             transformer.setOutputProperty(
 277                 OutputKeys.OMIT_XML_DECLARATION, "yes");
 278                 /*omitXmlDecl);*/
 279             // no equivalent for "setExpandEmptyElements"
 280             transformer.setOutputProperty(
 281                 OutputKeys.ENCODING,
 282                 charset);
 283 
 284             if (omitXmlDecl.equals("no") && xmlDecl == null) {
 285                 xmlDecl = "<?xml version=\"" + getOwnerDocument().getXmlVersion() + "\" encoding=\"" +
 286                     charset + "\" ?>";
 287             }
 288 
 289            StreamResult result = new StreamResult(out);


 294                 result = new StreamResult(writer);
 295             }
 296 
 297             if (log.isLoggable(Level.FINE)) {
 298                 log.log(Level.FINE, "SAAJ0190.impl.set.xml.declaration",
 299                         new String[] { omitXmlDecl });
 300                 log.log(Level.FINE, "SAAJ0191.impl.set.encoding",
 301                         new String[] { charset });
 302             }
 303 
 304             //StreamResult result = new StreamResult(out);
 305             transformer.transform(getContent(), result);
 306         } catch (Exception ex) {
 307             throw new IOException(ex.getMessage());
 308         }
 309     }
 310 
 311     /**
 312      * Serialize to FI if boolean parameter set.
 313      */
 314     @Override
 315     public void output(OutputStream out, boolean isFastInfoset)
 316         throws IOException
 317     {
 318         if (!isFastInfoset) {
 319             output(out);
 320         }
 321         else {
 322             try {
 323                 // Run transform and generate FI output from content
 324                 Transformer transformer = EfficientStreamingTransformer.newTransformer();
 325                     transformer.transform(getContent(),
 326                         FastInfosetReflection.FastInfosetResult_new(out));
 327             }
 328             catch (Exception ex) {
 329                 throw new IOException(ex.getMessage());
 330             }
 331         }
 332     }
 333 
 334     //    public void prettyPrint(OutputStream out) throws IOException {


 347     //        writer.write(getDocument());
 348     //    }
 349     //
 350     //    public void prettyPrint(Writer out) throws IOException {
 351     //        if (getDocument() == null)
 352     //            initDocument();
 353     //
 354     //        OutputFormat format = OutputFormat.createPrettyPrint();
 355     //
 356     //        format.setIndentSize(2);
 357     //        format.setNewlines(true);
 358     //        format.setTrimText(true);
 359     //        format.setPadText(true);
 360     //        format.setExpandEmptyElements(false);
 361     //
 362     //        XMLWriter writer = new XMLWriter(out, format);
 363     //        writer.write(getDocument());
 364     //    }
 365 
 366 
 367     @Override
 368      public SOAPElement setElementQName(QName newName) throws SOAPException {
 369         log.log(Level.SEVERE,
 370                 "SAAJ0146.impl.invalid.name.change.requested",
 371                 new Object[] {elementQName.getLocalPart(),
 372                               newName.getLocalPart()});
 373         throw new SOAPException("Cannot change name for "
 374                                 + elementQName.getLocalPart() + " to "
 375                                 + newName.getLocalPart());
 376      }
 377 
 378     @Override
 379     public void setStaxBridge(StaxBridge bridge) throws SOAPException {
 380         //set it on the body
 381         ((BodyImpl) getBody()).setStaxBridge(bridge);
 382     }
 383 
 384     @Override
 385     public StaxBridge getStaxBridge() throws SOAPException {
 386         return ((BodyImpl) getBody()).getStaxBridge();
 387     }
 388 
 389     @Override
 390     public XMLStreamReader getPayloadReader() throws SOAPException {
 391         return ((BodyImpl) getBody()).getPayloadReader();
 392     }
 393 
 394     @Override
 395     public void writeTo(final XMLStreamWriter writer) throws XMLStreamException, SOAPException {
 396         StaxBridge readBridge = this.getStaxBridge();
 397         if (readBridge != null && readBridge instanceof StaxLazySourceBridge) {
 398 //              StaxSoapWriteBridge writingBridge =  new StaxSoapWriteBridge(this);
 399 //              writingBridge.write(writer);
 400                 final String soapEnvNS = this.getNamespaceURI();
 401                 final DOMStreamReader reader = new DOMStreamReader(this);
 402                 XMLStreamReaderToXMLStreamWriter writingBridge =  new XMLStreamReaderToXMLStreamWriter();
 403                 writingBridge.bridge( new XMLStreamReaderToXMLStreamWriter.Breakpoint(reader, writer) {
 404                         @Override
 405                         public boolean proceedAfterStartElement()  {
 406                                 if ("Body".equals(reader.getLocalName()) && soapEnvNS.equals(reader.getNamespaceURI()) ){
 407                                         return false;
 408                                 } else
 409                                         return true;
 410                         }
 411             });//bridgeToBodyStartTag
 412             ((StaxLazySourceBridge)readBridge).writePayloadTo(writer);
 413             writer.writeEndElement();//body
 414             writer.writeEndElement();//env
 415             writer.writeEndDocument();
 416             writer.flush();
 417         } else {
 418                 LazyEnvelopeStaxReader lazyEnvReader = new LazyEnvelopeStaxReader(this);
 419                 XMLStreamReaderToXMLStreamWriter writingBridge = new XMLStreamReaderToXMLStreamWriter();
 420                 writingBridge.bridge(lazyEnvReader, writer);
 421 //            writingBridge.bridge(new XMLStreamReaderToXMLStreamWriter.Breakpoint(lazyEnvReader, writer));
 422         }
 423         //Assume the staxBridge is exhausted now since we would have read the body reader
 424         ((BodyImpl) getBody()).setPayloadStreamRead();


< prev index next >