axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sc...@apache.org
Subject svn commit: r603038 [1/2] - in /webservices/axis2/trunk/java/modules: jaxws/src/org/apache/axis2/datasource/ jaxws/src/org/apache/axis2/datasource/jaxb/ jaxws/src/org/apache/axis2/jaxws/message/attachments/ jaxws/src/org/apache/axis2/jaxws/message/data...
Date Mon, 10 Dec 2007 20:34:42 GMT
Author: scheu
Date: Mon Dec 10 12:34:39 2007
New Revision: 603038

URL: http://svn.apache.org/viewvc?rev=603038&view=rev
Log:
AXIS2-3395
Contributor:Rich Scheuerle
Added org.apache.axis2.datasource.jaxb.JAXBDataSource.
The JAXBDataSource supports usage of JAXB outside of the JAX-WS layer.
This is the first step to decomposing the JAX-WS Message model.
To make this happen, bits of the JAXWS message model were refactored.

Added:
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/SourceDataSource.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/XMLStringDataSource.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentMarshaller.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentUnmarshaller.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDSContext.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDataSource.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBXMLStreamWriterFilter.java
      - copied, changed from r599938, webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/impl/JAXBXMLStreamWriterFilter.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/XSDListUtils.java
      - copied, changed from r599938, webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/XSDListUtils.java
Removed:
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/XSDListUtils.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/impl/JAXBXMLStreamWriterFilter.java
Modified:
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentMarshaller.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentUnmarshaller.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/JAXBBlockContext.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/impl/JAXBBlockImpl.java
    webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/impl/XMLStringBlockImpl.java
    webservices/axis2/trunk/java/modules/jaxws/test/org/apache/axis2/jaxws/message/MessagePersistanceTests.java
    webservices/axis2/trunk/java/modules/metadata/src/org/apache/axis2/jaxws/ExceptionFactory.java
    webservices/axis2/trunk/java/modules/metadata/src/org/apache/axis2/jaxws/i18n/resource.properties

Added: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/SourceDataSource.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/SourceDataSource.java?rev=603038&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/SourceDataSource.java (added)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/SourceDataSource.java Mon Dec 10 12:34:39 2007
@@ -0,0 +1,126 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.axis2.datasource;
+
+
+import org.apache.axiom.om.OMDataSourceExt;
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.ds.OMDataSourceExtBase;
+import org.apache.axiom.om.util.StAXUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+
+/**
+ * OMDataSource backed by a source
+ */
+public class SourceDataSource extends OMDataSourceExtBase {
+    private static final Log log = LogFactory.getLog(SourceDataSource.class);
+    Source data;
+
+    public SourceDataSource(Source data) {
+        super();
+        this.data = data;
+    }
+
+    public void close() {
+    }
+
+    public OMDataSourceExt copy() {
+        return null;
+    }
+
+    public Object getObject() {
+        return data;
+    }
+
+    public XMLStreamReader getReader() throws XMLStreamException {
+
+        try {
+            String encoding = "utf-8";
+            InputStream is = new ByteArrayInputStream(getXMLBytes(encoding));
+            return StAXUtils.createXMLStreamReader(is, encoding);
+        } catch (UnsupportedEncodingException e) {
+            throw new XMLStreamException(e);
+        }
+    }
+
+    public byte[] getXMLBytes(String encoding) throws UnsupportedEncodingException {
+        if (log.isDebugEnabled()) {
+            log.debug("Start getXMLBytes");
+        }
+        byte[] bytes = null;
+        try {
+            bytes = (byte[]) null;
+
+            if (data instanceof StreamSource) {
+                InputStream is = ((StreamSource) data).getInputStream();
+                if (is != null) {
+                    bytes = getBytesFromStream(is);
+                }
+            } else {
+                ByteArrayOutputStream out = new ByteArrayOutputStream();
+                Result result = new StreamResult(out);
+                Transformer transformer = TransformerFactory.newInstance().newTransformer();
+                transformer.transform(data, result);
+                bytes = out.toByteArray();
+            }            
+        } catch (OMException e) {
+            throw e;
+        } catch (UnsupportedEncodingException e) {
+            throw e;
+        } catch (Throwable e) {
+            throw new OMException(e);
+        }
+        
+        if (log.isDebugEnabled()) {
+            log.debug("End getXMLBytes");
+        }
+        return bytes;
+    }
+
+    public boolean isDestructiveRead() {
+        return false;
+    }
+
+    public boolean isDestructiveWrite() {
+        return false;
+    }
+    
+    private static byte[] getBytesFromStream(InputStream is) throws IOException {
+        // TODO This code assumes that available is the length of the stream.
+        byte[] bytes = new byte[is.available()];
+        is.read(bytes);
+        return bytes;
+    }
+}

Added: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/XMLStringDataSource.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/XMLStringDataSource.java?rev=603038&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/XMLStringDataSource.java (added)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/XMLStringDataSource.java Mon Dec 10 12:34:39 2007
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.axis2.datasource;
+
+
+import org.apache.axiom.om.OMDataSourceExt;
+import org.apache.axiom.om.ds.OMDataSourceExtBase;
+import org.apache.axiom.om.util.StAXUtils;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+
+/**
+ * OMDataSource backed by a string containing xml data
+ */
+public class XMLStringDataSource extends OMDataSourceExtBase {
+    String data;
+
+    public XMLStringDataSource(String data) {
+        super();
+        this.data = data;
+    }
+
+    public void close() {
+    }
+
+    public OMDataSourceExt copy() {
+        return new XMLStringDataSource(data);
+    }
+
+    public Object getObject() {
+        return data;
+    }
+
+    public XMLStreamReader getReader() throws XMLStreamException {
+
+        try {
+            String encoding = "utf-8";
+            InputStream is = new ByteArrayInputStream(getXMLBytes(encoding));
+            return StAXUtils.createXMLStreamReader(is, encoding);
+        } catch (UnsupportedEncodingException e) {
+            throw new XMLStreamException(e);
+        }
+    }
+
+    public byte[] getXMLBytes(String encoding) throws UnsupportedEncodingException {
+        return data.getBytes(encoding);
+    }
+
+    public boolean isDestructiveRead() {
+        return false;
+    }
+
+    public boolean isDestructiveWrite() {
+        return false;
+    }
+    
+}

Added: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentMarshaller.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentMarshaller.java?rev=603038&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentMarshaller.java (added)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentMarshaller.java Mon Dec 10 12:34:39 2007
@@ -0,0 +1,220 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.axis2.datasource.jaxb;
+
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.OMText;
+import org.apache.axiom.om.impl.MTOMXMLStreamWriter;
+import org.apache.axiom.om.impl.llom.OMTextImpl;
+import org.apache.axis2.Constants.Configuration;
+import org.apache.axis2.context.MessageContext;
+import org.apache.axis2.transport.http.HTTPConstants;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.activation.DataHandler;
+import javax.mail.MessagingException;
+import javax.mail.internet.InternetHeaders;
+import javax.mail.internet.MimeBodyPart;
+import javax.mail.internet.MimePartDataSource;
+import javax.xml.bind.attachment.AttachmentMarshaller;
+import javax.xml.stream.XMLStreamWriter;
+
+/**
+ * An implementation of the JAXB AttachmentMarshaller that is used to handle binary data from JAXB
+ * and create populate the appropriate constructs on the MessageContext
+ */
+public class JAXBAttachmentMarshaller extends AttachmentMarshaller {
+
+    private static final Log log = LogFactory.getLog(JAXBAttachmentMarshaller.class);
+
+    private MessageContext msgContext;
+    private XMLStreamWriter writer;
+    private final String APPLICATION_OCTET = "application/octet-stream";
+    
+    /**
+     * Construct the JAXBAttachmentMarshaller that has access to the MessageContext
+     * @param msgContext
+     * @param writer
+     */
+    public JAXBAttachmentMarshaller(MessageContext msgContext, XMLStreamWriter writer) {
+        this.msgContext = msgContext;
+        this.writer = writer;
+    }
+
+    /**
+     * Override isXOPPackaget to calculate the isXOPPackage setting
+     */
+    public boolean isXOPPackage() {
+        boolean value = false;
+        
+        // For outbound messages, only trigger MTOM if
+        // the message is mtom enabled.
+        value = isMTOMEnabled();
+        
+        // If the writer is not an MTOM XMLStreamWriter then we don't have
+        // any place to store the attachment
+        if (!(writer instanceof MTOMXMLStreamWriter)) {
+            if (log.isDebugEnabled()) {
+                log.debug("The writer is not enabled for MTOM.  " +
+                                "MTOM values will not be optimized");
+            }
+            value = false;
+        }
+    
+        if (log.isDebugEnabled()){ 
+            log.debug("isXOPPackage returns " + value);
+        }
+        return value;
+
+    }
+
+    
+    /* (non-Javadoc)
+     * @see javax.xml.bind.attachment.AttachmentMarshaller#addMtomAttachment(byte[], int, int, java.lang.String, java.lang.String, java.lang.String)
+     */
+    public String addMtomAttachment(byte[] data, int offset, int length,
+                                    String mimeType, String namespace, String localPart) {
+
+        if (offset != 0 || length != data.length) {
+            int len = length - offset;
+            byte[] newData = new byte[len];
+            System.arraycopy(data, offset, newData, 0, len);
+            data = newData;
+        }
+        
+        if (mimeType == null || mimeType.length() == 0) {
+            mimeType = APPLICATION_OCTET;
+        }
+        
+        if (log.isDebugEnabled()){ 
+            log.debug("Adding MTOM/XOP byte array attachment for element: " + 
+                      "{" + namespace + "}" + localPart);
+        }
+        
+        String cid;
+        
+            try {
+                // Create MIME Body Part
+                InternetHeaders ih = new InternetHeaders();
+                ih.setHeader(HTTPConstants.HEADER_CONTENT_TYPE, mimeType);
+                MimeBodyPart mbp = new MimeBodyPart(ih, data);
+                
+                //Create a data source for the MIME Body Part
+                MimePartDataSource mpds = new MimePartDataSource(mbp);
+                
+                DataHandler dataHandler = new DataHandler(mpds);
+                cid = addDataHandler(dataHandler);
+                
+                // Add the content id to the mime body part
+                mbp.setHeader(HTTPConstants.HEADER_CONTENT_ID, cid);
+            } catch (MessagingException e) {
+                throw new OMException(e);
+            }
+        
+        return cid == null ? null : "cid:" + cid;
+    }
+    
+    
+    /* (non-Javadoc)
+     * @see javax.xml.bind.attachment.AttachmentMarshaller#addMtomAttachment(javax.activation.DataHandler, java.lang.String, java.lang.String)
+     */
+    public String addMtomAttachment(DataHandler data, String namespace, String localPart) {
+        if (log.isDebugEnabled()){ 
+            log.debug("Adding MTOM/XOP datahandler attachment for element: " + 
+                      "{" + namespace + "}" + localPart);
+        }
+        String cid = addDataHandler(data);
+        return cid == null ? null : "cid:" + cid;
+    }
+    
+    
+    /* (non-Javadoc)
+     * @see javax.xml.bind.attachment.AttachmentMarshaller#addSwaRefAttachment(javax.activation.DataHandler)
+     */
+    public String addSwaRefAttachment(DataHandler data) {
+        if (log.isDebugEnabled()){ 
+            log.debug("Adding SWAREF attachment");
+        }
+        
+        String cid = addDataHandler(data);
+        setDoingSWA();
+        return "cid:" + cid;
+    }
+    
+    /**
+     * Add the DataHandler to the writer and context
+     * @param dh
+     * @return
+     */
+    private String addDataHandler(DataHandler dh) {
+        String cid = null;
+        OMText textNode = null;
+        
+        // If this is an MTOMXMLStreamWriter then inform the writer 
+        // that it must write out this attchment (I guess we should do this
+        // even if the attachment is SWAREF ?)
+        if (writer instanceof MTOMXMLStreamWriter) {
+            textNode = new OMTextImpl(dh, null);
+            cid = textNode.getContentID();
+            ((MTOMXMLStreamWriter) writer).writeOptimized(textNode);
+            // Remember the attachment on the message.
+            addDataHandler(dh, cid);
+        }
+        
+        if (log.isDebugEnabled()){ 
+            log.debug("   content id=" + cid);
+            log.debug("   dataHandler  =" + dh);
+        }
+        return cid;
+    }
+
+    /**
+     * @return if MTOM enabled calculated from the context information
+     */
+    public boolean isMTOMEnabled() {
+        if (msgContext == null) {
+            return false;
+        } else {
+            String value = (String) msgContext.getProperty(Configuration.ENABLE_MTOM);
+            return ("true".equalsIgnoreCase(value));
+        }  
+    }
+    
+    /**
+     * Indicate on the context that SWA attachments are encountered
+     */
+    public void setDoingSWA() {
+        if (msgContext != null) {
+            msgContext.setDoingSwA(true);
+            msgContext.setProperty(Configuration.ENABLE_SWA, "true");
+        }
+    }
+    
+    /**
+     * Inform the context that an Attachment (DataHandler, CID) is written.
+     * @param dh
+     * @param cid
+     */
+    public void addDataHandler(DataHandler dh, String cid) {
+        if (msgContext != null) {
+            msgContext.addAttachment(cid, dh);
+        }
+    }
+}

Added: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentUnmarshaller.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentUnmarshaller.java?rev=603038&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentUnmarshaller.java (added)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBAttachmentUnmarshaller.java Mon Dec 10 12:34:39 2007
@@ -0,0 +1,157 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.axis2.datasource.jaxb;
+
+import org.apache.axiom.om.OMException;
+import org.apache.axis2.context.MessageContext;
+import org.apache.axis2.jaxws.i18n.Messages;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.activation.DataHandler;
+import javax.xml.bind.attachment.AttachmentUnmarshaller;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * JAXBAttachmentUnmarshaller
+ * <p/>
+ * An implementation of the <link>javax.xml.bind.attachment.AttachmentUnmarshaller</link> that is
+ * used for deserializing XOP elements into their corresponding binary data packages.
+ */
+public class JAXBAttachmentUnmarshaller extends AttachmentUnmarshaller {
+
+    private static final Log log = LogFactory.getLog(JAXBAttachmentUnmarshaller.class);
+
+    private MessageContext msgContext;
+
+    public JAXBAttachmentUnmarshaller(MessageContext msgContext) {
+        this.msgContext = msgContext;
+    }
+
+    public boolean isXOPPackage() {
+        
+        // Any message that is received might contain MTOM.
+        // So always return true.
+        boolean value = true;
+    
+        if (log.isDebugEnabled()){ 
+            log.debug("isXOPPackage returns " + value);
+        }
+        return value;
+    }
+
+    public byte[] getAttachmentAsByteArray(String cid) {
+        if (log.isDebugEnabled()) {
+            log.debug("Attempting to retrieve attachment [" + cid + "] as a byte[]");
+        }
+        DataHandler dh = getAttachmentAsDataHandler(cid);
+        if (dh != null) {
+            try {
+                return convert(dh);
+            } catch (IOException ioe) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Exception occurred while getting the byte[] " + ioe);
+                }
+                throw new OMException(ioe);
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug("returning null byte[]");
+        }
+        return null;
+    }
+
+    public DataHandler getAttachmentAsDataHandler(String cid) {
+        if (log.isDebugEnabled()) {
+            log.debug("Attempting to retrieve attachment [" + cid + "] as a DataHandler");
+        }
+
+        DataHandler dh = getDataHandler(cid);
+        if (dh != null) {
+            return dh;
+        } else {
+            String cid2 = getNewCID(cid);
+            if (log.isDebugEnabled()) {
+                log.debug("A dataHandler was not found for [" + cid + "] trying [" + cid2 + "]");
+            }
+            dh = getDataHandler(cid2);
+            if (dh != null) {
+                return dh;
+            }
+        }
+        // No Data Handler found
+        throw new OMException(Messages.getMessage("noDataHandler", cid));
+    }
+    
+    /**
+     * @param cid
+     * @return cid with translated characters
+     */
+    private String getNewCID(String cid) {
+        String cid2 = cid;
+
+        try {
+            cid2 = java.net.URLDecoder.decode(cid, "UTF-8");
+        } catch (Exception e) {
+            if (log.isDebugEnabled()) {
+                log.debug("getNewCID decoding " + cid + " as UTF-8 decoding error: " + e);
+            }
+        }
+        return cid2;
+    }
+
+    /**
+     * Read the bytes from the DataHandler
+     * 
+     * @param dh
+     * @return byte[]
+     * @throws IOException
+     */
+    private byte[] convert(DataHandler dh) throws IOException {
+        if (log.isDebugEnabled()) {
+            log.debug("Reading byte[] from DataHandler " + dh);
+        }
+        InputStream is = dh.getInputStream();
+        if (log.isDebugEnabled()) {
+            log.debug("DataHandler InputStream " + is);
+        }
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        byte[] b = new byte[1024];
+        int num = is.read(b);
+        if (log.isDebugEnabled()) {
+            if (num <= 0) {
+                log.debug("DataHandler InputStream contains no data. num=" + num);
+            }
+        }
+        while (num > 0) {
+            baos.write(b, 0, num);
+            num = is.read(b);
+        }
+        return baos.toByteArray();
+    }
+    
+    protected DataHandler getDataHandler(String cid) {
+        if (msgContext != null) {
+            return msgContext.getAttachment(cid);
+        }
+        return null;
+    }
+}

Added: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDSContext.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDSContext.java?rev=603038&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDSContext.java (added)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDSContext.java Mon Dec 10 12:34:39 2007
@@ -0,0 +1,677 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.axis2.datasource.jaxb;
+
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.impl.MTOMXMLStreamWriter;
+import org.apache.axis2.context.MessageContext;
+import org.apache.axis2.java.security.AccessController;
+import org.apache.axis2.jaxws.message.databinding.JAXBUtils;
+import org.apache.axis2.jaxws.message.util.XMLStreamWriterWithOS;
+import org.apache.axis2.jaxws.spi.Constants;
+import org.apache.axis2.jaxws.utility.XMLRootElementUtil;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.bind.attachment.AttachmentMarshaller;
+import javax.xml.bind.attachment.AttachmentUnmarshaller;
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.ws.Holder;
+import javax.xml.ws.WebServiceException;
+
+import java.io.OutputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.PrivilegedAction;
+import java.text.ParseException;
+import java.util.TreeSet;
+
+/*
+ * To marshal or unmarshal a JAXB object, the JAXBContext is necessary.
+ * In addition, access to the MessageContext and other context objects may be necessary
+ * to get classloader information, store attachments etc.
+ * 
+ * The JAXBDSContext bundles all of this information together.
+ */
+public class JAXBDSContext {
+
+    private static final Log log = LogFactory.getLog(JAXBDSContext.class);
+    public static final boolean DEBUG_ENABLED = log.isDebugEnabled();
+
+    private TreeSet<String> contextPackages;  // List of packages needed by the context
+    private String contextPackagesKey;        // Unique key that represents the set of contextPackages (usually toString)
+    private JAXBContext jaxbContext = null;   // JAXBContext
+    private JAXBUtils.CONSTRUCTION_TYPE       // How the JAXBContext is constructed
+            constructionType = JAXBUtils.CONSTRUCTION_TYPE.UNKNOWN;
+    private MessageContext msgContext;    
+
+    // There are two modes of marshalling and unmarshalling: "by java type" and "by schema element".
+    // The prefered mode is "by schema element" because it is safe and xml-centric.
+    // However there are some circumstances when "by schema element" is not available.
+    //    Examples: RPC Lit processing (the wire element is defined by a wsdl:part...not schema)
+    //              Doc/Lit Bare "Minimal" Processing (JAXB ObjectFactories are missing...and thus we must use "by type" for primitives/String)
+    // Please don't use "by java type" processing to get around errors.
+    private Class processType = null;
+    private boolean isxmlList =false;
+
+    /**
+     * Full Constructor JAXBDSContext (most performant)
+     *
+     * @param packages Set of packages needed by the JAXBContext.
+     */
+    public JAXBDSContext(TreeSet<String> packages, String packagesKey) {
+        this.contextPackages = packages;
+        this.contextPackagesKey = packagesKey;
+    }
+
+    /**
+     * Slightly slower constructor
+     *
+     * @param packages
+     */
+    public JAXBDSContext(TreeSet<String> packages) {
+        this(packages, packages.toString());
+    }
+
+    /**
+     * Normal Constructor JAXBBlockContext
+     *
+     * @param contextPackage
+     * @deprecated
+     */
+    public JAXBDSContext(String contextPackage) {
+        this.contextPackages = new TreeSet();
+        this.contextPackages.add(contextPackage);
+        this.contextPackagesKey = this.contextPackages.toString();
+    }
+
+    /**
+     * "Dispatch" Constructor Use this full constructor when the JAXBContent is provided by the
+     * customer.
+     *
+     * @param jaxbContext
+     */
+    public JAXBDSContext(JAXBContext jaxbContext) {
+        this.jaxbContext = jaxbContext;
+    }
+
+    /** @return Class representing type of the element */
+    public TreeSet<String> getContextPackages() {
+        return contextPackages;
+    }
+    
+    public JAXBContext getJAXBContext() throws JAXBException {
+        return getJAXBContext(null);
+    }
+
+    /**
+     * @return get the JAXBContext
+     * @throws JAXBException
+     */
+    public JAXBContext getJAXBContext(ClassLoader cl) throws JAXBException {
+        if (jaxbContext == null) {
+            if (log.isDebugEnabled()) {
+                log.debug(
+                        "A JAXBContext did not exist, creating a new one with the context packages.");
+            }
+            Holder<JAXBUtils.CONSTRUCTION_TYPE> constructType =
+                    new Holder<JAXBUtils.CONSTRUCTION_TYPE>();
+            jaxbContext =
+                    JAXBUtils.getJAXBContext(contextPackages, constructType, contextPackagesKey, cl);
+            constructionType = constructType.value;
+        } else {
+            if (log.isDebugEnabled()) {
+                log.debug("Using an existing JAXBContext");
+            }
+        }
+        return jaxbContext;
+    }
+
+    /** @return RPC Declared Type */
+    public Class getProcessType() {
+        return processType;
+    }
+
+    /**
+     * Set RPC Declared Type.  The use of use this property if the message is style=document is
+     * discouraged.
+     *
+     * @param type
+     */
+    public void setProcessType(Class type) {
+        processType = type;
+    }
+
+    public JAXBUtils.CONSTRUCTION_TYPE getConstructionType() {
+        return constructionType;
+    }
+
+    public boolean isxmlList() {
+        return isxmlList;
+    }
+
+    public void setIsxmlList(boolean isxmlList) {
+        this.isxmlList = isxmlList;
+    }
+    
+    public MessageContext getMessageContext() {
+        return msgContext;
+    }
+
+    public void setMessageContext(MessageContext messageContext) {
+        this.msgContext = messageContext;
+    }
+    
+    public ClassLoader getClassLoader() {
+        if (getMessageContext() != null) {
+            return (ClassLoader) getMessageContext().getProperty(Constants.CACHE_CLASSLOADER);
+        }
+        return null;
+    }
+    
+    /**
+     * Create an AttachmentMarshaller to marshal MTOM/SWA Attachments
+     * @param writer
+     * @return
+     */
+    protected AttachmentMarshaller createAttachmentMarshaller(XMLStreamWriter writer) {
+        return new JAXBAttachmentMarshaller(getMessageContext(), writer);
+    }
+    
+    /**
+     * Create an Attachment unmarshaller for unmarshalling MTOM/SWA Attachments
+     * @return AttachmentUnmarshaller
+     */
+    protected AttachmentUnmarshaller createAttachmentUnmarshaller() {
+        return new JAXBAttachmentUnmarshaller(getMessageContext());
+    }
+
+    /**
+     * Unmarshal the xml into a JAXB object
+     * @param reader
+     * @return
+     * @throws JAXBException
+     */
+    public Object unmarshal(XMLStreamReader reader) throws JAXBException {
+
+        // There may be a preferred classloader that should be used
+        ClassLoader cl = getClassLoader();
+        
+        Unmarshaller u = JAXBUtils.getJAXBUnmarshaller(getJAXBContext(cl));
+
+        
+        // Create an attachment unmarshaller
+        AttachmentUnmarshaller aum = createAttachmentUnmarshaller();
+
+        if (aum != null) {
+            if (DEBUG_ENABLED) {
+                log.debug("Adding JAXBAttachmentUnmarshaller to Unmarshaller");
+            } 
+            u.setAttachmentUnmarshaller(aum);
+        }
+
+        Object jaxb = null;
+
+        // Unmarshal into the business object.
+        if (getProcessType() == null) {
+            jaxb = unmarshalByElement(u, reader);   // preferred and always used for
+                                                    // style=document
+        } else {
+            jaxb = unmarshalByType(u,
+                                   reader,
+                                   getProcessType(),
+                                   isxmlList(),
+                                   getConstructionType());
+        }
+
+        // Successfully unmarshalled the object
+        JAXBUtils.releaseJAXBUnmarshaller(getJAXBContext(cl), u);
+        
+        // Don't close the reader.  The reader is owned by the caller, and it
+        // may contain other xml instance data (other than this JAXB object)
+        // reader.close();
+        return jaxb;
+    }
+    
+    /**
+     * Marshal the jaxb object
+     * @param obj
+     * @param writer
+     * @param am AttachmentMarshaller, optional Attachment
+     */
+    public void marshal(Object obj, 
+                        XMLStreamWriter writer) throws JAXBException {
+            // There may be a preferred classloader that should be used
+            ClassLoader cl = getClassLoader();
+            
+            
+            // Very easy, use the Context to get the Marshaller.
+            // Use the marshaller to write the object.
+            Marshaller m = JAXBUtils.getJAXBMarshaller(getJAXBContext(cl));
+            
+            AttachmentMarshaller am = createAttachmentMarshaller(writer);
+            if (am != null) {
+                if (DEBUG_ENABLED) {
+                    log.debug("Adding JAXBAttachmentMarshaller to Marshaller");
+                }
+                m.setAttachmentMarshaller(am);
+            }
+
+
+            // Marshal the object
+            if (getProcessType() == null) {
+                marshalByElement(obj, 
+                                 m, 
+                                 writer, 
+                                 !am.isXOPPackage());
+            } else {
+                marshalByType(obj,
+                              m,
+                              writer,
+                              getProcessType(),
+                              isxmlList(),
+                              getConstructionType());
+            }
+
+            // Successfully marshalled the data
+            JAXBUtils.releaseJAXBMarshaller(getJAXBContext(cl), m);
+    }
+    
+    
+    /**
+     * Preferred way to marshal objects.
+     * 
+     * @param b Object that can be rendered as an element and the element name is known by the
+     * Marshaller
+     * @param m Marshaller
+     * @param writer XMLStreamWriter
+     */
+    private static void marshalByElement(final Object b, final Marshaller m, 
+                                         final XMLStreamWriter writer,
+                                         final boolean optimize) {
+        AccessController.doPrivileged(new PrivilegedAction() {
+            public Object run() {
+                // Marshalling directly to the output stream is faster than marshalling through the
+                // XMLStreamWriter. 
+                // Take advantage of this optimization if there is an output stream.
+                try {
+                    OutputStream os = (optimize) ? getOutputStream(writer) : null;
+                    if (os != null) {
+                        if (DEBUG_ENABLED) {
+                            log.debug("Invoking marshalByElement.  " +
+                                        "Marshaling to an OutputStream. " +
+                                      "Object is "
+                                      + getDebugName(b));
+                        }
+                        writer.flush();
+                        m.marshal(b, os);
+                    } else {
+                        if (DEBUG_ENABLED) {
+                            log.debug("Invoking marshalByElement.  " +
+                                        "Marshaling to an XMLStreamWriter. " +
+                                      "Object is "
+                                      + getDebugName(b));
+                        }
+                        m.marshal(b, writer);
+                    }
+                } catch (OMException e) {
+                    throw e;
+                }
+                catch (Throwable t) {
+                    throw new OMException(t);
+                }
+                return null;
+            }});
+    }
+    
+    private static String getDebugName(Object o) {
+        return (o == null) ? "null" : o.getClass().getCanonicalName();
+    }
+
+    /**
+     * If the writer is backed by an OutputStream, then return the OutputStream
+     * @param writer
+     * @return OutputStream or null
+     */
+    private static OutputStream getOutputStream(XMLStreamWriter writer) throws XMLStreamException {
+        if (writer.getClass() == MTOMXMLStreamWriter.class) {
+            return ((MTOMXMLStreamWriter) writer).getOutputStream();
+        }
+        if (writer.getClass() == XMLStreamWriterWithOS.class) {
+            return ((XMLStreamWriterWithOS) writer).getOutputStream();
+        }
+        return null;
+    }
+    
+    /**
+     * The root element being read is defined by schema/JAXB; however its contents are known by
+     * schema/JAXB. Therefore we use unmarshal by the declared type (This method is used to
+     * unmarshal rpc elements)
+     * 
+     * @param u Unmarshaller
+     * @param reader XMLStreamReader
+     * @param type Class
+     * @return Object
+     * @throws WebServiceException
+     */
+    public static Object unmarshalByType(final Unmarshaller u, final XMLStreamReader reader,
+                                          final Class type, final boolean isList,
+                                          final JAXBUtils.CONSTRUCTION_TYPE ctype)
+        throws WebServiceException {
+
+        if (DEBUG_ENABLED) {
+            log.debug("Invoking unmarshalByType.");
+        }
+
+        return AccessController.doPrivileged(new PrivilegedAction() {
+            public Object run() {
+                try {
+                    // Unfortunately RPC is type based. Thus a
+                    // declared type must be used to unmarshal the xml.
+                    Object jaxb;
+
+                    if (!isList) {
+                        // case: We are not unmarshalling an xsd:list but an Array.
+
+                        if (type.isArray()) {
+                            // If the context is created using package
+                            // we will not have common arrays or type array in the context
+                            // so let use a differet way to unmarshal this type
+                            if (ctype == JAXBUtils.CONSTRUCTION_TYPE.BY_CONTEXT_PATH) {
+                                jaxb = unmarshalAsListOrArray(reader, u, type);
+                            }
+                            // list on client array on server, Can happen only in start from java
+                            // case.
+                            else if ((ctype == JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY)) {
+                                // The type could be any Object or primitive
+                                // I will first unmarshall the xmldata to a String[]
+                                // Then use the unmarshalled jaxbElement to create
+                                // proper type Object Array.
+                                jaxb = u.unmarshal(reader, String[].class);
+                                Object typeObj = getTypeEnabledObject(jaxb);
+                                // Now convert String Array in to the required Type Array.
+                                if (getTypeEnabledObject(typeObj) instanceof String[]) {
+                                    String[] strArray = (String[]) typeObj;
+                                    String strTokens = new String();
+                                    for (String str : strArray) {
+                                        strTokens = strTokens + " " + str;
+                                    }
+                                    QName qName =
+                                            XMLRootElementUtil.
+                                            getXmlRootElementQNameFromObject(jaxb);
+                                    Object obj = XSDListUtils.fromXSDListString(strTokens, type);
+                                    jaxb = new JAXBElement(qName, type, obj);
+                                }
+                            } else {
+                                jaxb = u.unmarshal(reader, type);
+                            }
+
+                        } else if (type.isEnum()) {
+                            // When JAXBContext is created using a context path, it will not 
+                            // include Enum classes.
+                            // These classes have @XmlEnum annotation but not @XmlType/@XmlElement,
+                            // so the user will see MarshallingEx, class not known to ctxt.
+                            // 
+                            // This is a jax-b defect, for now this fix is in place to pass CTS.
+                            // This only fixes the
+                            // situation where the enum is the top-level object (e.g., message-part
+                            // in rpc-lit scenario)
+                            //
+                            // Sample of what enum looks like:
+                            // @XmlEnum public enum EnumString {
+                            // @XmlEnumValue("String1") STRING_1("String1"),
+                            // @XmlEnumValue("String2") STRING_2("String2");
+                            //
+                            // public static getValue(String){} <-- resolves a "value" to an emum
+                            // object
+                            // ... }
+                            if (DEBUG_ENABLED) {
+                                log.debug("unmarshalByType. Unmarshalling " + type.getName()
+                                        + " as Enum");
+                            }
+
+                            JAXBElement<String> enumValue = u.unmarshal(reader, String.class);
+
+                            if (enumValue != null) {
+                                Method m =
+                                        type.getMethod("fromValue", new Class[] { String.class });
+                                jaxb = m.invoke(null, new Object[] { enumValue.getValue() });
+                            } else {
+                                jaxb = null;
+                            }
+                        }
+                        //Normal case: We are not unmarshalling a xsd:list or Array
+                        else {
+                            jaxb = u.unmarshal(reader, type);
+                        }
+
+                    } else {
+                        // If this is an xsd:list, we need to return the appropriate
+                        // list or array (see NOTE above)
+                        // First unmarshal as a String
+                        //Second convert the String into a list or array
+                        jaxb = unmarshalAsListOrArray(reader, u, type);
+                    }
+                    return jaxb;
+                } catch (OMException e) {
+                    throw e;
+                } catch (Throwable t) {
+                    throw new OMException(t);
+                }
+            }
+        });
+    }
+
+    /**
+     * convert the String into a list or array
+     * @param <T>
+     * @param jaxb
+     * @param type
+     * @return
+     * @throws IllegalAccessException
+     * @throws ParseException
+     * @throws NoSuchMethodException
+     * @throws InstantiationException
+     * @throws DatatypeConfigurationException
+     * @throws InvocationTargetException
+     */
+    public static Object unmarshalAsListOrArray(XMLStreamReader reader, Unmarshaller u, 
+                                                 Class type)
+        throws IllegalAccessException, ParseException,NoSuchMethodException,InstantiationException,
+        DatatypeConfigurationException,InvocationTargetException,JAXBException {
+        //If this is an xsd:list, we need to return the appropriate
+        // list or array (see NOTE above)
+        // First unmarshal as a String
+        Object jaxb = u.unmarshal(reader, String.class);
+        //Second convert the String into a list or array
+        if (getTypeEnabledObject(jaxb) instanceof String) {
+            QName qName = XMLRootElementUtil.getXmlRootElementQNameFromObject(jaxb);
+            Object obj = XSDListUtils.fromXSDListString((String) getTypeEnabledObject(jaxb), type);
+            return new JAXBElement(qName, type, obj);
+        } else {
+            return jaxb;
+        }
+
+    }
+
+    /**
+     * Return type enabled object
+     *
+     * @param obj type or element enabled object
+     * @return type enabled object
+     */
+    static Object getTypeEnabledObject(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        if (obj instanceof JAXBElement) {
+            return ((JAXBElement) obj).getValue();
+        }
+        return obj;
+    }
+
+    /**
+     * Marshal objects by type
+     * 
+     * @param b Object that can be rendered as an element, but the element name is not known to the
+     * schema (i.e. rpc)
+     * @param m Marshaller
+     * @param writer XMLStreamWriter
+     * @param type
+     */
+    private static void marshalByType(final Object b, final Marshaller m,
+                                      final XMLStreamWriter writer, final Class type,
+                                      final boolean isList, final JAXBUtils.CONSTRUCTION_TYPE ctype)
+        throws WebServiceException {
+        AccessController.doPrivileged(new PrivilegedAction() {
+            public Object run() {
+                try {
+
+                    // NOTE
+                    // Example:
+                    // <xsd:simpleType name="LongList">
+                    // <xsd:list>
+                    // <xsd:simpleType>
+                    // <xsd:restriction base="xsd:unsignedInt"/>
+                    // </xsd:simpleType>
+                    // </xsd:list>
+                    // </xsd:simpleType>
+                    // <element name="myLong" nillable="true" type="impl:LongList"/>
+                    //
+                    // LongList will be represented as an int[]
+                    // On the wire myLong will be represented as a list of integers
+                    // with intervening whitespace
+                    // <myLong>1 2 3</myLong>
+                    //
+                    // Unfortunately, we are trying to marshal by type. Therefore
+                    // we want to marshal an element (foo) that is unknown to schema.
+                    // If we use the normal marshal code, the wire will look like
+                    // this (which is incorrect):
+                    // <foo><item>1</item><item>2</item><item>3</item></foo>
+                    //
+                    // The solution is to detect this situation and marshal the
+                    // String instead. Then we get the correct wire format:
+                    // <foo>1 2 3</foo>
+                    Object jbo = b;
+
+                    if (isList || (type != null && type.isArray())) {
+                        if (DEBUG_ENABLED) {
+                            log.debug("marshalling type which is a List or Array");
+                        }
+                        // We conver to xsdListString only if the type is not known
+                        // to the context. In case a jaxbcontext is created from package
+                        // the array types or list are not know to the context.
+                        if (ctype == JAXBUtils.CONSTRUCTION_TYPE.BY_CONTEXT_PATH) {
+                            QName qName = XMLRootElementUtil.getXmlRootElementQNameFromObject(b);
+                            String text = XSDListUtils.toXSDListString(getTypeEnabledObject(b));
+                            jbo = new JAXBElement(qName, String.class, text);
+                        } else if (ctype == JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY) {
+                            // do nothing common array types should be know to the jaxbcontext.
+                            // so do not use xsdListString conversion.
+                        }
+                    }
+
+                    // When JAXBContext is created using a context path, it will not include Enum
+                    // classes.
+                    // These classes have @XmlEnum annotation but not @XmlType/@XmlElement, so the
+                    // user will see MarshallingEx, class not known to ctxt.
+                    // 
+                    // This is a jax-b defect, for now this fix is in place to pass CTS. This only
+                    // fixes the
+                    // situation where the enum is the top-level object (e.g., message-part in
+                    // rpc-lit scenario)
+                    //
+                    // Sample of what enum looks like:
+                    // @XmlEnum public enum EnumString {
+                    // @XmlEnumValue("String1") STRING_1("String1"),
+                    // @XmlEnumValue("String2") STRING_2("String2");
+                    // ... }
+                    if (type.isEnum()) {
+                        if (b != null) {
+                            if (DEBUG_ENABLED) {
+                                log.debug("marshalByType. Marshaling " + type.getName()
+                                        + " as Enum");
+                            }
+                            JAXBElement jbe = (JAXBElement) b;
+                            String value = XMLRootElementUtil.getEnumValue((Enum) jbe.getValue());
+
+                            jbo = new JAXBElement(jbe.getName(), String.class, value);
+                        }
+                    }
+
+                    if (DEBUG_ENABLED) {
+                        log.debug("Invoking marshalByType.  " +
+                                        "Marshaling to an XMLStreamWriter. Object is "
+                                + getDebugName(b));
+                    }
+                    m.marshal(jbo, writer);
+
+                } catch (OMException e) {
+                    throw e;
+                } catch (Throwable t) {
+                    throw new OMException(t);
+                }
+                return null;
+            }
+        });
+    }
+
+    /**
+     * Preferred way to unmarshal objects
+     * 
+     * @param u Unmarshaller
+     * @param reader XMLStreamReader
+     * @return Object that represents an element
+     * @throws WebServiceException
+     */
+    public static Object unmarshalByElement(final Unmarshaller u, final XMLStreamReader reader)
+        throws WebServiceException {
+        try {
+            if (DEBUG_ENABLED) {
+                log.debug("Invoking unMarshalByElement");
+            }
+            return AccessController.doPrivileged(new PrivilegedAction() {
+                public Object run() {
+                    try {
+                        return u.unmarshal(reader);
+                    } catch (OMException e) {
+                        throw e;
+                    } catch (Throwable t) {
+                        throw new OMException(t);
+                    }
+                }
+            });
+
+        } catch (OMException e) {
+            throw e;
+        } catch (Throwable t) {
+            throw new OMException(t);
+        }
+    }
+
+}

Added: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDataSource.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDataSource.java?rev=603038&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDataSource.java (added)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBDataSource.java Mon Dec 10 12:34:39 2007
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.axis2.datasource.jaxb;
+
+
+import org.apache.axiom.om.OMDataSourceExt;
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.OMOutputFormat;
+import org.apache.axiom.om.ds.OMDataSourceExtBase;
+import org.apache.axiom.om.impl.MTOMXMLStreamWriter;
+import org.apache.axiom.om.util.StAXUtils;
+import org.apache.axis2.jaxws.message.util.XMLStreamWriterWithOS;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.xml.bind.JAXBException;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+
+/**
+ * OMDataSource backed by a jaxb object
+ */
+public class JAXBDataSource extends OMDataSourceExtBase {
+    
+    private static final Log log = LogFactory.getLog(JAXBDataSource.class);
+    
+    Object jaxb;
+    JAXBDSContext context;
+
+    public JAXBDataSource(Object jaxb, JAXBDSContext context) {
+        super();
+        this.jaxb = jaxb;
+        this.context = context;
+    }
+
+    public void close() {
+    }
+
+    public OMDataSourceExt copy() {
+        return new JAXBDataSource(jaxb, context);
+    }
+
+    public Object getObject() {
+        return jaxb;
+    }
+
+    public XMLStreamReader getReader() throws XMLStreamException {
+
+        try {
+            String encoding = "utf-8";
+            InputStream is = new ByteArrayInputStream(getXMLBytes(encoding));
+            return StAXUtils.createXMLStreamReader(is, encoding);
+        } catch (UnsupportedEncodingException e) {
+            throw new XMLStreamException(e);
+        }
+    }
+
+    public void serialize(OutputStream output, OMOutputFormat format) throws XMLStreamException {
+        MTOMXMLStreamWriter writer = new MTOMXMLStreamWriter(output, format);
+        serialize(writer);
+        writer.flush();
+        try {
+            writer.close();
+        } catch (XMLStreamException e) {
+            // An exception can occur if nothing is written to the 
+            // writer.  This is possible if the underlying data source
+            // writers to the output stream directly.
+            if (log.isDebugEnabled()) {
+                log.debug("Catching and swallowing exception " + e);
+            }
+        }
+    }
+
+    public void serialize(Writer writerTarget, OMOutputFormat format) throws XMLStreamException {
+        MTOMXMLStreamWriter writer =
+            new MTOMXMLStreamWriter(StAXUtils.createXMLStreamWriter(writerTarget));
+        writer.setOutputFormat(format);
+        serialize(writer);
+        writer.flush();
+        writer.close();
+    }
+
+    public void serialize(XMLStreamWriter xmlWriter) throws XMLStreamException {
+        try {
+            context.marshal(jaxb, xmlWriter);
+        } catch (JAXBException je) {
+            if (log.isDebugEnabled()) {
+                try {
+                    log.debug("JAXBContext for marshal failure:" + 
+                              context.getJAXBContext(context.getClassLoader()));
+                } catch (Exception e) {
+                }
+            }
+            throw new XMLStreamException(je);
+        }
+    }
+    
+    public byte[] getXMLBytes(String encoding) throws UnsupportedEncodingException {
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+            // Exposes getOutputStream, which allows faster writes.
+            XMLStreamWriterWithOS writer = new XMLStreamWriterWithOS(baos, encoding);
+
+            // Write the business object to the writer
+            serialize(writer);
+
+            // Flush the writer
+            writer.flush();
+            writer.close();
+            return baos.toByteArray();
+        } catch (XMLStreamException e) {
+            throw new OMException(e);
+        }
+    }
+
+    public boolean isDestructiveRead() {
+        return false;
+    }
+
+    public boolean isDestructiveWrite() {
+        return false;
+    }
+    
+}

Copied: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBXMLStreamWriterFilter.java (from r599938, webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/impl/JAXBXMLStreamWriterFilter.java)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBXMLStreamWriterFilter.java?p2=webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBXMLStreamWriterFilter.java&p1=webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/impl/JAXBXMLStreamWriterFilter.java&r1=599938&r2=603038&rev=603038&view=diff
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/impl/JAXBXMLStreamWriterFilter.java (original)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/JAXBXMLStreamWriterFilter.java Mon Dec 10 12:34:39 2007
@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.apache.axis2.jaxws.message.databinding.impl;
+package org.apache.axis2.datasource.jaxb;
 
 import org.apache.axis2.jaxws.utility.JavaUtils;
 import org.apache.commons.logging.Log;

Copied: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/XSDListUtils.java (from r599938, webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/XSDListUtils.java)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/XSDListUtils.java?p2=webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/XSDListUtils.java&p1=webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/XSDListUtils.java&r1=599938&r2=603038&rev=603038&view=diff
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/XSDListUtils.java (original)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/datasource/jaxb/XSDListUtils.java Mon Dec 10 12:34:39 2007
@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.apache.axis2.jaxws.message.databinding;
+package org.apache.axis2.datasource.jaxb;
 
 import org.apache.axis2.jaxws.i18n.Messages;
 

Modified: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentMarshaller.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentMarshaller.java?rev=603038&r1=603037&r2=603038&view=diff
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentMarshaller.java (original)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentMarshaller.java Mon Dec 10 12:34:39 2007
@@ -18,150 +18,50 @@
  */
 package org.apache.axis2.jaxws.message.attachments;
 
-import org.apache.axiom.om.OMText;
-import org.apache.axiom.om.impl.MTOMXMLStreamWriter;
-import org.apache.axiom.om.impl.llom.OMTextImpl;
-import org.apache.axis2.jaxws.ExceptionFactory;
 import org.apache.axis2.jaxws.message.Message;
-import org.apache.axis2.transport.http.HTTPConstants;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
 import javax.activation.DataHandler;
-import javax.mail.internet.InternetHeaders;
-import javax.mail.internet.MimeBodyPart;
-import javax.mail.internet.MimePartDataSource;
-import javax.xml.bind.attachment.AttachmentMarshaller;
 import javax.xml.stream.XMLStreamWriter;
 
 /**
  * An implementation of the JAXB AttachmentMarshaller that is used to handle binary data from JAXB
  * and create populate the appropriate constructs within the JAX-WS Message Model.
  */
-public class JAXBAttachmentMarshaller extends AttachmentMarshaller {
-
-    private static final Log log = LogFactory.getLog(JAXBAttachmentMarshaller.class);
-
+public class JAXBAttachmentMarshaller extends org.apache.axis2.datasource.jaxb.JAXBAttachmentMarshaller {
     private Message message;
-    private XMLStreamWriter writer;
-    private final String APPLICATION_OCTET = "application/octet-stream";
     
     public JAXBAttachmentMarshaller(Message message, XMLStreamWriter writer) {
+        super(null, writer);
         this.message = message;
-        this.writer = writer;
     }
-
-    @Override
-    public boolean isXOPPackage() {
-        boolean value = false;
-        
-        // For outbound messages, only trigger MTOM if
-        // the message is mtom enabled (which indicates that
-        // the api dispatch/provider/proxy/impl has an MTOM binding)
-        if (message != null) {
-          value = message.isMTOMEnabled();
-        }
-        
-        
-        // If the writer is not an MTOM XMLStreamWriter then we don't have
-        // any place to store the attachment
-        if (!(writer instanceof MTOMXMLStreamWriter)) {
-            if (log.isDebugEnabled()) {
-                log.debug("The writer is not enabled for MTOM.  " +
-                                "MTOM values will not be optimized");
-            }
-            value = false;
-        }
-    
-        if (log.isDebugEnabled()){ 
-            log.debug("isXOPPackage returns " + value);
-        }
-        return value;
-
-    }
-
-    @Override
-    public String addMtomAttachment(byte[] data, int offset, int length,
-                                    String mimeType, String namespace, String localPart) {
-
-        if (offset != 0 || length != data.length) {
-            int len = length - offset;
-            byte[] newData = new byte[len];
-            System.arraycopy(data, offset, newData, 0, len);
-            data = newData;
-        }
-        
-        if (mimeType == null || mimeType.length() == 0) {
-            mimeType = APPLICATION_OCTET;
-        }
-        
-        if (log.isDebugEnabled()){ 
-            log.debug("Adding MTOM/XOP byte array attachment for element: " + 
-                      "{" + namespace + "}" + localPart);
-        }
-        
-        String cid;
-        try {
-            // Create MIME Body Part
-            InternetHeaders ih = new InternetHeaders();
-            ih.setHeader(HTTPConstants.HEADER_CONTENT_TYPE, mimeType);
-            MimeBodyPart mbp = new MimeBodyPart(ih, data);
-            
-            //Create a data source for the MIME Body Part
-            MimePartDataSource mpds = new MimePartDataSource(mbp);
-            
-            DataHandler dataHandler = new DataHandler(mpds);
-            cid = addDataHandler(dataHandler);
-            
-            // Add the content id to the mime body part
-            mbp.setHeader(HTTPConstants.HEADER_CONTENT_ID, cid);
-        } catch (Throwable t) {
-            throw ExceptionFactory.makeWebServiceException(t);
-        }
-        return cid == null ? null : "cid:" + cid;
+    /**
+     * @return if MTOM enabled calculated from the context information
+     */
+    public boolean isMTOMEnabled() {
+        if (message == null) {
+            return false;
+        } else {
+            return message.isMTOMEnabled();
+        }  
     }
     
-    @Override
-    public String addMtomAttachment(DataHandler data, String namespace, String localPart) {
-        if (log.isDebugEnabled()){ 
-            log.debug("Adding MTOM/XOP datahandler attachment for element: " + 
-                      "{" + namespace + "}" + localPart);
-        }
-        String cid = addDataHandler(data);
-        return cid == null ? null : "cid:" + cid;
-    }
-    
-    @Override
-    public String addSwaRefAttachment(DataHandler data) {
-        if (log.isDebugEnabled()){ 
-            log.debug("Adding SWAREF attachment");
+    /**
+     * Indicate on the context that SWA attachments are encountered
+     */
+    public void setDoingSWA() {
+        if (message != null) {
+            message.setDoingSWA(true);
         }
-        
-        String cid = addDataHandler(data);
-        message.setDoingSWA(true);
-        return "cid:" + cid;
     }
     
-    private String addDataHandler(DataHandler dh) {
-        String cid = null;
-        OMText textNode = null;
-        
-        // If this is an MTOMXMLStreamWriter then inform the writer 
-        // that it must write out this attchment (I guess we should do this
-        // even if the attachment is SWAREF ?)
-        if (writer instanceof MTOMXMLStreamWriter) {
-            textNode = new OMTextImpl(dh, null);
-            cid = textNode.getContentID();
-            ((MTOMXMLStreamWriter) writer).writeOptimized(textNode);
-            // Remember the attachment on the message.
+    /**
+     * Inform the context that an Attachment (DataHandler, CID) is written.
+     * @param dh
+     * @param cid
+     */
+    public void addDataHandler(DataHandler dh, String cid) {
+        if (message != null) {
             message.addDataHandler(dh, cid);
         }
-        
-        if (log.isDebugEnabled()){ 
-            log.debug("   content id=" + cid);
-            log.debug("   dataHandler  =" + dh);
-        }
-        return cid;
     }
-
 }

Modified: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentUnmarshaller.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentUnmarshaller.java?rev=603038&r1=603037&r2=603038&view=diff
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentUnmarshaller.java (original)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/attachments/JAXBAttachmentUnmarshaller.java Mon Dec 10 12:34:39 2007
@@ -18,17 +18,11 @@
  */
 package org.apache.axis2.jaxws.message.attachments;
 
-import org.apache.axis2.jaxws.ExceptionFactory;
 import org.apache.axis2.jaxws.message.Message;
-import org.apache.axis2.jaxws.utility.JavaUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import javax.activation.DataHandler;
-import javax.xml.bind.attachment.AttachmentUnmarshaller;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
 
 /**
  * JAXBAttachmentUnmarshaller
@@ -36,119 +30,21 @@
  * An implementation of the <link>javax.xml.bind.attachment.AttachmentUnmarshaller</link> that is
  * used for deserializing XOP elements into their corresponding binary data packages.
  */
-public class JAXBAttachmentUnmarshaller extends AttachmentUnmarshaller {
-
-    private static final Log log = LogFactory.getLog(JAXBAttachmentUnmarshaller.class);
+public class JAXBAttachmentUnmarshaller extends org.apache.axis2.datasource.jaxb.JAXBAttachmentUnmarshaller {
 
     private Message message;
 
     public JAXBAttachmentUnmarshaller(Message message) {
+        super(null);
         this.message = message;
     }
 
-    @Override
-    public boolean isXOPPackage() {
-        
-        // Any message that is received might contain MTOM.
-        // So always return true.
-        boolean value = true;
-    
-        if (log.isDebugEnabled()){ 
-            log.debug("isXOPPackage returns " + value);
-        }
-        return value;
-    }
-
-    @Override
-    public byte[] getAttachmentAsByteArray(String cid) {
-        if (log.isDebugEnabled()) {
-            log.debug("Attempting to retrieve attachment [" + cid + "] as a byte[]");
-        }
-        DataHandler dh = getAttachmentAsDataHandler(cid);
-        if (dh != null) {
-            try {
-                return convert(dh);
-            } catch (IOException ioe) {
-                if (log.isDebugEnabled()) {
-                    log.debug("Exception occurred while getting the byte[] " + ioe);
-                }
-                throw ExceptionFactory.makeWebServiceException(ioe);
-            }
-        }
-        if (log.isDebugEnabled()) {
-            log.debug("returning null byte[]");
-        }
+    protected DataHandler getDataHandler(String cid) {
+        if (message != null) {
+            return super.getDataHandler(cid);
+        } 
         return null;
     }
 
-    @Override
-    public DataHandler getAttachmentAsDataHandler(String cid) {
-        if (log.isDebugEnabled()) {
-            log.debug("Attempting to retrieve attachment [" + cid + "] as a DataHandler");
-        }
-
-        DataHandler dh = message.getDataHandler(cid);
-        if (dh != null) {
-            return dh;
-        } else {
-            String cid2 = getNewCID(cid);
-            if (log.isDebugEnabled()) {
-                log.debug("A dataHandler was not found for [" + cid + "] trying [" + cid2 + "]");
-            }
-            dh = message.getDataHandler(cid2);
-            if (dh != null) {
-                return dh;
-            }
-        }
-        // No Data Handler found
-        throw ExceptionFactory.makeWebServiceException("A data handler was not found " +
-                        "for content id " + cid);
-    }
     
-    /**
-     * @param cid
-     * @return cid with translated characters
-     */
-    private String getNewCID(String cid) {
-        String cid2 = cid;
-
-        try {
-            cid2 = java.net.URLDecoder.decode(cid, "UTF-8");
-        } catch (Exception e) {
-            if (log.isDebugEnabled()) {
-                log.debug("getNewCID decoding " + cid + " as UTF-8 decoding error: " + e);
-            }
-        }
-        return cid2;
-    }
-
-    /**
-     * Read the bytes from the DataHandler
-     * 
-     * @param dh
-     * @return byte[]
-     * @throws IOException
-     */
-    private byte[] convert(DataHandler dh) throws IOException {
-        if (log.isDebugEnabled()) {
-            log.debug("Reading byte[] from DataHandler " + dh);
-        }
-        InputStream is = dh.getInputStream();
-        if (log.isDebugEnabled()) {
-            log.debug("DataHandler InputStream " + is);
-        }
-        ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        byte[] b = new byte[1024];
-        int num = is.read(b);
-        if (log.isDebugEnabled()) {
-            if (num <= 0) {
-                log.debug("DataHandler InputStream contains no data. num=" + num);
-            }
-        }
-        while (num > 0) {
-            baos.write(b, 0, num);
-            num = is.read(b);
-        }
-        return baos.toByteArray();
-    }
 }

Modified: webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/JAXBBlockContext.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/JAXBBlockContext.java?rev=603038&r1=603037&r2=603038&view=diff
==============================================================================
--- webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/JAXBBlockContext.java (original)
+++ webservices/axis2/trunk/java/modules/jaxws/src/org/apache/axis2/jaxws/message/databinding/JAXBBlockContext.java Mon Dec 10 12:34:39 2007
@@ -18,50 +18,36 @@
  */
 package org.apache.axis2.jaxws.message.databinding;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.apache.axis2.context.MessageContext;
+import org.apache.axis2.datasource.jaxb.JAXBDSContext;
+import org.apache.axis2.jaxws.message.Message;
+import org.apache.axis2.jaxws.message.attachments.JAXBAttachmentMarshaller;
+import org.apache.axis2.jaxws.message.attachments.JAXBAttachmentUnmarshaller;
+import org.apache.axis2.jaxws.spi.Constants;
 
 import javax.xml.bind.JAXBContext;
-import javax.xml.bind.JAXBException;
-import javax.xml.ws.Holder;
+import javax.xml.bind.attachment.AttachmentMarshaller;
+import javax.xml.bind.attachment.AttachmentUnmarshaller;
+import javax.xml.stream.XMLStreamWriter;
+
 import java.util.TreeSet;
 
 /*
- * A JAXBBlockContext controls access to the JAXB Context
+ * A JAXBBlockContext controls access to the JAXBContext
  * In addition the JAXBBlockContext contains additional contextural information needed
  * by the JAX-WS component
- * 
- * This class is immutable after construction.
  */
 
-public class JAXBBlockContext {
-
-    private static final Log log = LogFactory.getLog(JAXBBlockContext.class);
-
-    private TreeSet<String> contextPackages;  // List of packages needed by the context
-    private String contextPackagesKey;        // Unique key that represents the set of contextPackages (usually toString)
-    private JAXBContext jaxbContext = null;   // JAXBContext
-    private JAXBUtils.CONSTRUCTION_TYPE       // How the JAXBContext is constructed
-            constructionType = JAXBUtils.CONSTRUCTION_TYPE.UNKNOWN;
-
-    // There are two modes of marshalling and unmarshalling: "by java type" and "by schema element".
-    // The prefered mode is "by schema element" because it is safe and xml-centric.
-    // However there are some circumstances when "by schema element" is not available.
-    //    Examples: RPC Lit processing (the wire element is defined by a wsdl:part...not schema)
-    //              Doc/Lit Bare "Minimal" Processing (JAXB ObjectFactories are missing...and thus we must use "by type" for primitives/String)
-    // Please don't use "by java type" processing to get around errors.
-
-    private Class processType = null;
-    private boolean isxmlList =false;
+public class JAXBBlockContext extends JAXBDSContext {
 
+    Message message = null;
     /**
      * Full Constructor JAXBBlockContext (most performant)
      *
      * @param packages Set of packages needed by the JAXBContext.
      */
     public JAXBBlockContext(TreeSet<String> packages, String packagesKey) {
-        this.contextPackages = packages;
-        this.contextPackagesKey = packagesKey;
+        super(packages, packagesKey);
     }
 
     /**
@@ -80,9 +66,7 @@
      * @deprecated
      */
     public JAXBBlockContext(String contextPackage) {
-        this.contextPackages = new TreeSet();
-        this.contextPackages.add(contextPackage);
-        this.contextPackagesKey = this.contextPackages.toString();
+        super(contextPackage);
     }
 
     /**
@@ -92,66 +76,39 @@
      * @param jaxbContext
      */
     public JAXBBlockContext(JAXBContext jaxbContext) {
-        this.jaxbContext = jaxbContext;
+        super(jaxbContext);
     }
 
-    /** @return Class representing type of the element */
-    public TreeSet<String> getContextPackages() {
-        return contextPackages;
-    }
-    
-    public JAXBContext getJAXBContext() throws JAXBException {
-        return getJAXBContext(null);
-    }
-
-    /**
-     * @return get the JAXBContext
-     * @throws JAXBException
-     */
-    public JAXBContext getJAXBContext(ClassLoader cl) throws JAXBException {
-        if (jaxbContext == null) {
-            if (log.isDebugEnabled()) {
-                log.debug(
-                        "A JAXBContext did not exist, creating a new one with the context packages.");
-            }
-            Holder<JAXBUtils.CONSTRUCTION_TYPE> constructType =
-                    new Holder<JAXBUtils.CONSTRUCTION_TYPE>();
-            jaxbContext =
-                    JAXBUtils.getJAXBContext(contextPackages, constructType, contextPackagesKey, cl);
-            constructionType = constructType.value;
-        } else {
-            if (log.isDebugEnabled()) {
-                log.debug("Using an existing JAXBContext");
-            }
-        }
-        return jaxbContext;
+    public Message getMessage() {
+        return message;
     }
 
-    /** @return RPC Declared Type */
-    public Class getProcessType() {
-        return processType;
+    public void setMessage(Message message) {
+        this.message = message;
     }
 
-    /**
-     * Set RPC Declared Type.  The use of use this property if the message is style=document is
-     * discouraged.
-     *
-     * @param type
-     */
-    public void setProcessType(Class type) {
-        processType = type;
+    protected AttachmentMarshaller createAttachmentMarshaller(XMLStreamWriter writer) {
+        return new JAXBAttachmentMarshaller(getMessage(), writer);
     }
-
-    public JAXBUtils.CONSTRUCTION_TYPE getConstructionType() {
-        return constructionType;
+    
+    protected AttachmentUnmarshaller createAttachmentUnmarshaller() {
+        return new JAXBAttachmentUnmarshaller(getMessage());
     }
 
-    public boolean isxmlList() {
-        return isxmlList;
+    public ClassLoader getClassLoader() {
+        if(message != null && message.getMessageContext() != null) {
+            return (ClassLoader) message.getMessageContext().
+                getProperty(Constants.CACHE_CLASSLOADER);
+        }
+        return super.getClassLoader();
     }
 
-    public void setIsxmlList(boolean isxmlList) {
-        this.isxmlList = isxmlList;
+    public MessageContext getMessageContext() {
+        if(message != null && message.getMessageContext() != null &&
+           message.getMessageContext().getAxisMessageContext() != null) {
+            super.setMessageContext(message.getMessageContext().getAxisMessageContext());
+        }
+        return super.getMessageContext();
     }
     
 }



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message