summaryrefslogtreecommitdiffstats
path: root/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main
diff options
context:
space:
mode:
Diffstat (limited to 'sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main')
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/AxiomHelper.java140
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXB2OMElement.java84
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXBDataSource.java128
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/OMElement2JAXB.java106
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBCustomBuilder.java114
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDSContext.java191
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDataSourceExt.java144
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/SourceDataSource.java123
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStreamWriterWithOS.java246
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStringDataSource.java84
-rw-r--r--sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/resources/META-INF/services/org.apache.tuscany.sca.databinding.PullTransformer27
11 files changed, 1387 insertions, 0 deletions
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/AxiomHelper.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/AxiomHelper.java
new file mode 100644
index 0000000000..93277e77bf
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/AxiomHelper.java
@@ -0,0 +1,140 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom;
+
+import javax.xml.namespace.QName;
+
+import org.apache.axiom.om.OMAbstractFactory;
+import org.apache.axiom.om.OMDataSource;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNamespace;
+import org.apache.axiom.om.OMXMLParserWrapper;
+import org.apache.axiom.om.impl.builder.StAXBuilder;
+import org.apache.tuscany.sca.databinding.TransformationContext;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.util.XMLType;
+
+/**
+ * Helper for AXIOM
+ *
+ * @version $Rev$ $Date$
+ */
+public class AxiomHelper {
+ private static final String DEFAULT_PREFIX = "_ns_";
+
+ private AxiomHelper() {
+ }
+
+ /**
+ * See http://issues.apache.org/jira/browse/WSCOMMONS-240
+ * @param om
+ */
+ public static void completeAndClose(OMElement om) {
+ // Get the builder associated with the om element
+ OMXMLParserWrapper builder = om.getBuilder();
+ if (builder != null) {
+ if (builder instanceof StAXBuilder) {
+ ((StAXBuilder)builder).releaseParserOnClose(true);
+ }
+ OMElement document = builder.getDocumentElement();
+ if (document != null) {
+ document.build();
+ }
+ }
+ if (builder instanceof StAXBuilder) {
+ ((StAXBuilder)builder).close();
+ }
+ }
+
+ /**
+ * This method will close the builder immediately. Any subsequent Axiom objects won't
+ * be built or accessible.
+ */
+ public static void closeImmediately(OMElement om) {
+ // Get the builder associated with the om element
+ OMXMLParserWrapper builder = om.getBuilder();
+ if (builder != null) {
+ if (builder instanceof StAXBuilder) {
+ ((StAXBuilder)builder).releaseParserOnClose(true);
+ ((StAXBuilder)builder).close();
+ }
+ // builder.close();
+ }
+ }
+
+ /**
+ * @param context
+ * @param element
+ */
+ public static void adjustElementName(TransformationContext context, OMElement element) {
+ if (context != null) {
+ DataType<?> dataType = context.getTargetDataType();
+ Object logical = dataType == null ? null : dataType.getLogical();
+ if (!(logical instanceof XMLType)) {
+ return;
+ }
+ XMLType xmlType = (XMLType)logical;
+ if (xmlType.isElement() && !xmlType.getElementName().equals(element.getQName())) {
+ // FIXME:: Throw exception or switch to the new Element?
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ QName name = xmlType.getElementName();
+ OMNamespace namespace = factory.createOMNamespace(name.getNamespaceURI(), name.getPrefix());
+ element.setNamespace(namespace);
+ element.setLocalName(name.getLocalPart());
+ }
+ }
+ }
+
+ public static OMElement createOMElement(OMFactory factory, QName element) {
+ String localName = element.getLocalPart();
+ OMNamespace ns = createOMNamespace(factory, element);
+
+ return factory.createOMElement(localName, ns);
+
+ }
+
+ public static OMElement createOMElement(OMFactory factory, QName element, OMDataSource dataSource) {
+ String localName = element.getLocalPart();
+ OMNamespace ns = createOMNamespace(factory, element);
+
+ return factory.createOMElement(dataSource, localName, ns);
+
+ }
+
+ /**
+ * @param factory
+ * @param name
+ * @return
+ */
+ public static OMNamespace createOMNamespace(OMFactory factory, QName name) {
+ String namespaceURI = name.getNamespaceURI();
+ String prefix = name.getPrefix();
+
+ OMNamespace ns = null;
+ // Qualified Element: we need an OMNamespace
+ if (prefix.length() == 0) {
+ // The prefix does not appear to be specified, let's create one
+ prefix = DEFAULT_PREFIX;
+ }
+ ns = factory.createOMNamespace(namespaceURI, prefix);
+ return ns;
+ }
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXB2OMElement.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXB2OMElement.java
new file mode 100644
index 0000000000..c90a1c6d5a
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXB2OMElement.java
@@ -0,0 +1,84 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.namespace.QName;
+
+import org.apache.axiom.om.OMAbstractFactory;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMFactory;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.databinding.BaseTransformer;
+import org.apache.tuscany.sca.databinding.PullTransformer;
+import org.apache.tuscany.sca.databinding.TransformationContext;
+import org.apache.tuscany.sca.databinding.TransformationException;
+import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper;
+import org.apache.tuscany.sca.databinding.jaxb.JAXBDataBinding;
+
+/**
+ * JAXB Object --> AXIOM OMElement transformer
+ *
+ * @version $Rev$ $Date$
+ */
+public class JAXB2OMElement extends BaseTransformer<Object, OMElement> implements PullTransformer<Object, OMElement> {
+ private OMFactory factory = OMAbstractFactory.getOMFactory();
+ private JAXBContextHelper contextHelper;
+
+ public JAXB2OMElement(ExtensionPointRegistry registry) {
+ super();
+ contextHelper = JAXBContextHelper.getInstance(registry);
+ }
+
+ @Override
+ public String getSourceDataBinding() {
+ return JAXBDataBinding.NAME;
+ }
+
+ public OMElement transform(Object source, TransformationContext context) throws TransformationException {
+ JAXBContext jaxbContext;
+ try {
+ jaxbContext = contextHelper.createJAXBContext(context, true);
+ } catch (JAXBException e) {
+ throw new TransformationException(e);
+ }
+ Object element = JAXBContextHelper.createJAXBElement(jaxbContext, context.getTargetDataType(), source);
+ QName name = jaxbContext.createJAXBIntrospector().getElementName(element);
+ JAXBDataSource dataSource = new JAXBDataSource(element, jaxbContext, contextHelper);
+ OMElement omElement = AxiomHelper.createOMElement(factory, name, dataSource);
+ return omElement;
+ }
+
+ @Override
+ public Class<Object> getSourceType() {
+ return Object.class;
+ }
+
+ @Override
+ public Class<OMElement> getTargetType() {
+ return OMElement.class;
+ }
+
+ @Override
+ public int getWeight() {
+ return 3000;
+ }
+
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXBDataSource.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXBDataSource.java
new file mode 100644
index 0000000000..0dacce996f
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXBDataSource.java
@@ -0,0 +1,128 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom;
+
+import java.io.OutputStream;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.Marshaller;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.axiom.om.OMDataSource;
+import org.apache.axiom.om.OMOutputFormat;
+import org.apache.axiom.om.util.StAXUtils;
+import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper;
+
+/**
+ *
+ * @version $Rev$ $Date$
+ */
+public class JAXBDataSource implements OMDataSource {
+ private JAXBContext context;
+ private Object element;
+ private JAXBContextHelper contextHelper;
+
+ public JAXBDataSource(Object element, JAXBContext context, JAXBContextHelper contextHelper) {
+ this.element = element;
+ this.context = context;
+ this.contextHelper = contextHelper;
+ }
+
+ public XMLStreamReader getReader() throws XMLStreamException {
+ // FIXME: [rfeng] This is a quick and dirty implementation
+ // We could use the fastinfoset to optimize the roundtrip
+ StringWriter writer = new StringWriter();
+ serialize(writer, new OMOutputFormat());
+ StringReader reader = new StringReader(writer.toString());
+ // FIXME: We need to use Tuscany extension point to create the reader
+ return StAXUtils.createXMLStreamReader(reader);
+ }
+
+ public void serialize(final XMLStreamWriter xmlWriter) throws XMLStreamException {
+ try {
+ // marshaller.setProperty(Marshaller.JAXB_ENCODING, format.getCharSetEncoding());
+ AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
+ public Object run() throws Exception {
+ Marshaller marshaller = null;
+ try {
+ marshaller = contextHelper.getMarshaller(context);
+ marshaller.marshal(element, xmlWriter);
+ } finally {
+ contextHelper.releaseJAXBMarshaller(context, marshaller);
+ }
+ return null;
+ }
+ });
+ } catch (PrivilegedActionException e) {
+ throw new XMLStreamException(e.getException());
+ }
+ }
+
+ public void serialize(final OutputStream output, OMOutputFormat format) throws XMLStreamException {
+ try {
+ // marshaller.setProperty(Marshaller.JAXB_ENCODING, format.getCharSetEncoding());
+ AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
+ public Object run() throws Exception {
+ Marshaller marshaller = null;
+ try {
+ marshaller = contextHelper.getMarshaller(context);
+ marshaller.marshal(element, output);
+ } finally {
+ contextHelper.releaseJAXBMarshaller(context, marshaller);
+ }
+ return null;
+ }
+ });
+ } catch (PrivilegedActionException e) {
+ throw new XMLStreamException(e.getException());
+ }
+ }
+
+ public void serialize(final Writer writer, OMOutputFormat format) throws XMLStreamException {
+ try {
+ AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
+ public Object run() throws Exception {
+ Marshaller marshaller = null;
+ try {
+ marshaller = contextHelper.getMarshaller(context);
+ marshaller.marshal(element, writer);
+ } finally {
+ contextHelper.releaseJAXBMarshaller(context, marshaller);
+ }
+ return null;
+ }
+ });
+ } catch (PrivilegedActionException e) {
+ throw new XMLStreamException(e.getException());
+ }
+ }
+
+ public Object getObject() {
+ return element;
+ }
+
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/OMElement2JAXB.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/OMElement2JAXB.java
new file mode 100644
index 0000000000..f7de7f4425
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/OMElement2JAXB.java
@@ -0,0 +1,106 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom;
+
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.util.StreamReaderDelegate;
+
+import org.apache.axiom.om.OMElement;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.databinding.BaseTransformer;
+import org.apache.tuscany.sca.databinding.PullTransformer;
+import org.apache.tuscany.sca.databinding.TransformationContext;
+import org.apache.tuscany.sca.databinding.TransformationException;
+import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class OMElement2JAXB extends BaseTransformer<OMElement, Object> implements PullTransformer<OMElement, Object> {
+ private JAXBContextHelper contextHelper;
+
+ public OMElement2JAXB(ExtensionPointRegistry registry) {
+ super();
+ contextHelper = JAXBContextHelper.getInstance(registry);
+ }
+ @Override
+ public String getSourceDataBinding() {
+ return org.apache.axiom.om.OMElement.class.getName();
+ }
+
+ public Object transform(final OMElement source, final TransformationContext context) throws TransformationException {
+ try {
+ return AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
+ public Object run() throws JAXBException, XMLStreamException {
+ Unmarshaller unmarshaller = null;
+ XMLStreamReader reader = null;
+ Object result = null;
+ // Marshalling directly to the output stream is faster than marshalling through the
+ // XMLStreamWriter.
+ // Take advantage of this optimization if there is an output stream.
+ JAXBContext jaxbContext = contextHelper.createJAXBContext(context, false);
+ try {
+ unmarshaller = contextHelper.getUnmarshaller(jaxbContext);
+ reader = source.getXMLStreamReaderWithoutCaching();
+ // https://issues.apache.org/jira/browse/WSCOMMONS-395
+ reader = new StreamReaderDelegate(reader) {
+ // Fix the issue in WSCOMMONS-395
+ public String getAttributeType(int index) {
+ String type = super.getAttributeType(index);
+ return type == null ? "CDATA" : type;
+ }
+ };
+ result = unmarshaller.unmarshal(reader, JAXBContextHelper.getJavaType(context.getTargetDataType()));
+ } finally {
+ if (reader != null) {
+ reader.close();
+ }
+ contextHelper.releaseJAXBUnmarshaller(jaxbContext, unmarshaller);
+ }
+ return JAXBContextHelper.createReturnValue(jaxbContext, context.getTargetDataType(), result);
+ }
+ });
+ } catch (PrivilegedActionException e) {
+ throw new TransformationException(e.getException());
+ }
+ }
+
+ @Override
+ public Class<OMElement> getSourceType() {
+ return OMElement.class;
+ }
+
+ @Override
+ public Class<Object> getTargetType() {
+ return Object.class;
+ }
+
+ @Override
+ public int getWeight() {
+ return 3000;
+ }
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBCustomBuilder.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBCustomBuilder.java
new file mode 100644
index 0000000000..f30a6c1cb8
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBCustomBuilder.java
@@ -0,0 +1,114 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom.ext;
+
+import javax.xml.bind.JAXBException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.axiom.om.OMContainer;
+import org.apache.axiom.om.OMDataSource;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNamespace;
+import org.apache.axiom.om.impl.builder.CustomBuilder;
+
+/**
+ * JAXBCustomBuilder creates an OMSourcedElement backed by a JAXBDataSource
+ * for the specified namespace and localPart.
+ */
+public class JAXBCustomBuilder implements CustomBuilder {
+
+ private JAXBDSContext jdsContext;
+
+ /**
+ * Create a JAXBCustomBuilder
+ * @param context JAXBDSContext
+ */
+ public JAXBCustomBuilder(JAXBDSContext context) {
+ super();
+ this.jdsContext = context;
+ }
+
+ public OMElement create(String namespace,
+ String localPart,
+ OMContainer parent,
+ XMLStreamReader reader,
+ OMFactory factory) throws OMException {
+
+ // There are some situations where we want to use normal
+ // unmarshalling, so return null
+ if (!shouldUnmarshal(namespace, localPart)) {
+ // JAXBCustomBuilderMonitor.updateTotalFailedCreates();
+ return null;
+ }
+ try {
+ // Create an OMSourcedElement backed by an unmarshalled JAXB object
+ OMNamespace ns = factory.createOMNamespace(namespace, reader.getPrefix());
+
+ Object jaxb = jdsContext.unmarshal(reader);
+
+ OMDataSource ds = new JAXBDataSourceExt(jaxb, jdsContext);
+ OMElement omse = factory.createOMElement(ds, localPart, ns);
+
+ parent.addChild(omse);
+ // JAXBCustomBuilderMonitor.updateTotalCreates();
+ return omse;
+ } catch (JAXBException e) {
+ // JAXBCustomBuilderMonitor.updateTotalFailedCreates();
+ throw new OMException(e);
+ }
+ }
+
+ /**
+ * The namespace identifier for the SOAP 1.1 envelope.
+ */
+ public static final String URI_NS_SOAP_1_1_ENVELOPE = "http://schemas.xmlsoap.org/soap/envelope/";
+ /**
+ * The namespace identifier for the SOAP 1.2 envelope.
+ */
+ public static final String URI_NS_SOAP_1_2_ENVELOPE = "http://www.w3.org/2003/05/soap-envelope";
+
+ /**
+ * @param namespace
+ * @param localPart
+ * @return true if this ns and local part is acceptable for unmarshalling
+ */
+ private boolean shouldUnmarshal(String namespace, String localPart) {
+
+ // Don't unmarshall SOAPFaults or anything else in the SOAP
+ // namespace.
+ // Don't unmarshall elements that are unqualified
+ if (localPart == null || namespace == null
+ || namespace.length() == 0
+ || URI_NS_SOAP_1_1_ENVELOPE.equals(namespace)
+ || URI_NS_SOAP_1_2_ENVELOPE.equals(namespace)) {
+ return false;
+ }
+
+ // Don't unmarshal if this looks like encrypted data
+ if (localPart.equals("EncryptedData")) {
+ return false;
+ }
+
+ return true;
+
+ }
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDSContext.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDSContext.java
new file mode 100644
index 0000000000..f6bd33864f
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDSContext.java
@@ -0,0 +1,191 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom.ext;
+
+import java.io.OutputStream;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.bind.attachment.AttachmentMarshaller;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.impl.MTOMXMLStreamWriter;
+import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper;
+
+/*
+ * 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 Logger log = Logger.getLogger(JAXBDSContext.class.getName());
+ private static final boolean DEBUG_ENABLED = log.isLoggable(Level.FINER);
+
+ private JAXBContext jaxbContext = null; // JAXBContext
+ private JAXBContextHelper contextHelper;
+
+ /**
+ * "Dispatch" Constructor Use this full constructor when the JAXBContent is provided by the
+ * customer.
+ *
+ * @param jaxbContext
+ */
+ public JAXBDSContext(JAXBContext jaxbContext, JAXBContextHelper contextHelper) {
+ this.jaxbContext = jaxbContext;
+ this.contextHelper = contextHelper;
+ }
+
+ public JAXBContext getJAXBContext() {
+ return jaxbContext;
+ }
+
+ /**
+ * Unmarshal the xml into a JAXB object
+ * @param reader
+ * @return
+ * @throws JAXBException
+ */
+ public Object unmarshal(XMLStreamReader reader) throws JAXBException {
+
+ Unmarshaller u = contextHelper.getUnmarshaller(getJAXBContext());
+
+ Object jaxb = null;
+
+ // Unmarshal into the business object.
+ jaxb = unmarshalElement(u, reader); // preferred and always used for
+ // style=document
+
+ // 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 {
+
+ // Very easy, use the Context to get the Marshaller.
+ // Use the marshaller to write the object.
+ Marshaller m = contextHelper.getMarshaller(getJAXBContext());
+ AttachmentMarshaller am = m.getAttachmentMarshaller();
+ boolean xop = am != null ? am.isXOPPackage() : false;
+ // Marshal the object
+ marshalElement(obj, m, writer, !xop);
+ }
+
+ /**
+ * 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 marshalElement(final Object b,
+ final Marshaller m,
+ final XMLStreamWriter writer,
+ final boolean optimize) {
+ AccessController.doPrivileged(new PrivilegedAction<Object>() {
+ 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) {
+ writer.flush();
+ m.marshal(b, os);
+ } else {
+ m.marshal(b, writer);
+ }
+ } catch (OMException e) {
+ throw e;
+ } catch (Throwable t) {
+ throw new OMException(t);
+ }
+ return null;
+ }
+ });
+ }
+
+ /**
+ * 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;
+ }
+
+ /**
+ * Preferred way to unmarshal objects
+ *
+ * @param u Unmarshaller
+ * @param reader XMLStreamReader
+ * @return Object that represents an element
+ */
+ private static Object unmarshalElement(final Unmarshaller u, final XMLStreamReader reader) {
+ try {
+ return AccessController.doPrivileged(new PrivilegedAction<Object>() {
+ 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);
+ }
+ }
+
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDataSourceExt.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDataSourceExt.java
new file mode 100644
index 0000000000..5a5afc13cb
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDataSourceExt.java
@@ -0,0 +1,144 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom.ext;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.bind.JAXBException;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+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;
+
+/**
+ * OMDataSource backed by a jaxb object
+ */
+public class JAXBDataSourceExt extends OMDataSourceExtBase {
+
+ private static final Logger log = Logger.getLogger(JAXBDataSourceExt.class.getName());
+
+ private Object jaxb;
+ private JAXBDSContext context;
+
+ public JAXBDataSourceExt(Object jaxb, JAXBDSContext context) {
+ super();
+ this.jaxb = jaxb;
+ this.context = context;
+ }
+
+ public void close() {
+ }
+
+ public OMDataSourceExt copy() {
+ return new JAXBDataSourceExt(jaxb, context);
+ }
+
+ public Object getObject() {
+ return jaxb;
+ }
+
+ public JAXBDSContext getContext() {
+ return context;
+ }
+
+ 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.isLoggable(Level.FINER)) {
+ log.finer("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) {
+ 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;
+ }
+
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/SourceDataSource.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/SourceDataSource.java
new file mode 100644
index 0000000000..0a12654524
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/SourceDataSource.java
@@ -0,0 +1,123 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom.ext;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+
+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 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;
+
+/**
+ * OMDataSource backed by a source
+ */
+public class SourceDataSource extends OMDataSourceExtBase {
+ private Source data;
+
+ public SourceDataSource(Source data) {
+ super();
+ this.data = data;
+ }
+
+ public void close() {
+ }
+
+ public OMDataSourceExt copy() {
+ return new SourceDataSource(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 {
+ 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);
+ }
+
+ return bytes;
+ }
+
+ public boolean isDestructiveRead() {
+ return false;
+ }
+
+ public boolean isDestructiveWrite() {
+ return false;
+ }
+
+ private static byte[] getBytesFromStream(InputStream is) throws IOException {
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ byte[] buf = new byte[4096];
+ while (true) {
+ int size = is.read(buf);
+ if (size < 0) {
+ break;
+ }
+ bos.write(buf, 0, size);
+ }
+ return bos.toByteArray();
+ }
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStreamWriterWithOS.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStreamWriterWithOS.java
new file mode 100644
index 0000000000..44e34c3647
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStreamWriterWithOS.java
@@ -0,0 +1,246 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom.ext;
+
+import java.io.OutputStream;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.axiom.om.util.StAXUtils;
+
+/**
+ * XMLStreamReader that exposes direct access to the OutputStream.
+ * Writing to the output stream is faster in some cases.
+ */
+public class XMLStreamWriterWithOS implements XMLStreamWriter {
+ private XMLStreamWriter writer;
+ private String charSetEncoding;
+ private OutputStream os;
+
+ public XMLStreamWriterWithOS(OutputStream os, String charSetEncoding) throws XMLStreamException {
+ super();
+ writer = null; // Writer is created when needed
+ this.os = os;
+ this.charSetEncoding = charSetEncoding;
+ }
+
+ /**
+ * The writer is created lazily.
+ * If only the output stream is used, then the writer is never created.
+ */
+ private void createWriter() throws XMLStreamException {
+ if (writer == null) {
+ writer = StAXUtils.createXMLStreamWriter(os, charSetEncoding);
+ }
+ }
+
+ public void close() throws XMLStreamException {
+ if (writer != null) {
+ writer.close();
+ }
+ }
+
+ public void flush() throws XMLStreamException {
+ if (writer != null) {
+ writer.flush();
+ }
+ }
+
+ public NamespaceContext getNamespaceContext() {
+ try {
+ createWriter();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ return writer.getNamespaceContext();
+ }
+
+ public String getPrefix(String arg0) throws XMLStreamException {
+ createWriter();
+ return writer.getPrefix(arg0);
+ }
+
+ public Object getProperty(String arg0) throws IllegalArgumentException {
+ try {
+ createWriter();
+ } catch (XMLStreamException e) {
+ throw new IllegalArgumentException(e);
+ }
+ return writer.getProperty(arg0);
+ }
+
+ public void setDefaultNamespace(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.setDefaultNamespace(arg0);
+ }
+
+ public void setNamespaceContext(NamespaceContext arg0) throws XMLStreamException {
+ createWriter();
+ writer.setNamespaceContext(arg0);
+ }
+
+ public void setPrefix(String arg0, String arg1) throws XMLStreamException {
+ createWriter();
+ writer.setPrefix(arg0, arg1);
+ }
+
+ public void writeAttribute(String arg0, String arg1, String arg2, String arg3) throws XMLStreamException {
+ createWriter();
+ writer.writeAttribute(arg0, arg1, arg2, arg3);
+ }
+
+ public void writeAttribute(String arg0, String arg1, String arg2) throws XMLStreamException {
+ createWriter();
+ writer.writeAttribute(arg0, arg1, arg2);
+ }
+
+ public void writeAttribute(String arg0, String arg1) throws XMLStreamException {
+ createWriter();
+ writer.writeAttribute(arg0, arg1);
+ }
+
+ public void writeCData(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeCData(arg0);
+ }
+
+ public void writeCharacters(char[] arg0, int arg1, int arg2) throws XMLStreamException {
+ createWriter();
+ writer.writeCharacters(arg0, arg1, arg2);
+ }
+
+ public void writeCharacters(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeCharacters(arg0);
+ }
+
+ public void writeComment(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeComment(arg0);
+ }
+
+ public void writeDefaultNamespace(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeDefaultNamespace(arg0);
+ }
+
+ public void writeDTD(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeDTD(arg0);
+ }
+
+ public void writeEmptyElement(String arg0, String arg1, String arg2) throws XMLStreamException {
+ createWriter();
+ writer.writeEmptyElement(arg0, arg1, arg2);
+ }
+
+ public void writeEmptyElement(String arg0, String arg1) throws XMLStreamException {
+ createWriter();
+ writer.writeEmptyElement(arg0, arg1);
+ }
+
+ public void writeEmptyElement(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeEmptyElement(arg0);
+ }
+
+ public void writeEndDocument() throws XMLStreamException {
+ createWriter();
+ writer.writeEndDocument();
+ }
+
+ public void writeEndElement() throws XMLStreamException {
+ createWriter();
+ writer.writeEndElement();
+ }
+
+ public void writeEntityRef(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeEntityRef(arg0);
+ }
+
+ public void writeNamespace(String arg0, String arg1) throws XMLStreamException {
+ createWriter();
+ writer.writeNamespace(arg0, arg1);
+ }
+
+ public void writeProcessingInstruction(String arg0, String arg1) throws XMLStreamException {
+ createWriter();
+ writer.writeProcessingInstruction(arg0, arg1);
+ }
+
+ public void writeProcessingInstruction(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeProcessingInstruction(arg0);
+ }
+
+ public void writeStartDocument() throws XMLStreamException {
+ createWriter();
+ writer.writeStartDocument();
+ }
+
+ public void writeStartDocument(String arg0, String arg1) throws XMLStreamException {
+ createWriter();
+ writer.writeStartDocument(arg0, arg1);
+ }
+
+ public void writeStartDocument(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeStartDocument(arg0);
+ }
+
+ public void writeStartElement(String arg0, String arg1, String arg2) throws XMLStreamException {
+ createWriter();
+ writer.writeStartElement(arg0, arg1, arg2);
+ }
+
+ public void writeStartElement(String arg0, String arg1) throws XMLStreamException {
+ createWriter();
+ writer.writeStartElement(arg0, arg1);
+ }
+
+ public void writeStartElement(String arg0) throws XMLStreamException {
+ createWriter();
+ writer.writeStartElement(arg0);
+ }
+
+ /**
+ * If this XMLStreamWriter is connected to an OutputStream
+ * then the OutputStream is returned. This allows a node
+ * (perhaps an OMSourcedElement) to write its content
+ * directly to the OutputStream.
+ * @return OutputStream or null
+ */
+ public OutputStream getOutputStream() throws XMLStreamException {
+
+ if (os != null) {
+ // Flush the state of the writer..Many times the
+ // write defers the writing of tag characters (>)
+ // until the next write. Flush out this character
+ if (writer != null) {
+ this.writeCharacters("");
+ this.flush();
+ }
+ }
+ return os;
+ }
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStringDataSource.java b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStringDataSource.java
new file mode 100644
index 0000000000..e8e3193e24
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStringDataSource.java
@@ -0,0 +1,84 @@
+/*
+ * 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.tuscany.sca.databinding.jaxb.axiom.ext;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.axiom.om.OMDataSourceExt;
+import org.apache.axiom.om.OMOutputFormat;
+import org.apache.axiom.om.ds.OMDataSourceExtBase;
+import org.apache.axiom.om.util.StAXUtils;
+
+/**
+ * OMDataSource backed by a string containing xml data
+ */
+public class XMLStringDataSource extends OMDataSourceExtBase {
+ private 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 {
+ StringReader reader = new StringReader(data);
+ return StAXUtils.createXMLStreamReader(reader);
+ }
+
+ public void serialize(Writer writer, OMOutputFormat format) throws XMLStreamException {
+ try {
+ writer.write(data);
+ } catch (UnsupportedEncodingException e) {
+ throw new XMLStreamException(e);
+ } catch (IOException 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;
+ }
+
+}
diff --git a/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/resources/META-INF/services/org.apache.tuscany.sca.databinding.PullTransformer b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/resources/META-INF/services/org.apache.tuscany.sca.databinding.PullTransformer
new file mode 100644
index 0000000000..d1799abaff
--- /dev/null
+++ b/sandbox/sebastien/java/vhost/modules/databinding-jaxb-axiom/src/main/resources/META-INF/services/org.apache.tuscany.sca.databinding.PullTransformer
@@ -0,0 +1,27 @@
+# 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.
+
+# Implementation classes for the transformers
+org.apache.tuscany.sca.databinding.jaxb.axiom.JAXB2OMElement;source=javax.xml.bind.JAXBElement,target=org.apache.axiom.om.OMElement,weight=3000
+org.apache.tuscany.sca.databinding.jaxb.axiom.JAXB2OMElement;source=java:simpleType,target=org.apache.axiom.om.OMElement,weight=3000
+org.apache.tuscany.sca.databinding.jaxb.axiom.JAXB2OMElement;source=java:complexType,target=org.apache.axiom.om.OMElement,weight=3000
+
+org.apache.tuscany.sca.databinding.jaxb.axiom.OMElement2JAXB;source=org.apache.axiom.om.OMElement,target=javax.xml.bind.JAXBElement,weight=3000,public=false
+org.apache.tuscany.sca.databinding.jaxb.axiom.OMElement2JAXB;source=org.apache.axiom.om.OMElement,target=java:complexType,weight=90000,public=false
+org.apache.tuscany.sca.databinding.jaxb.axiom.OMElement2JAXB;source=org.apache.axiom.om.OMElement,target=java:simpleType,weight=90000,public=false
+
+