This is an automated email from the ASF dual-hosted git repository.
veithen pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ws-axiom.git
The following commit(s) were added to refs/heads/master by this push:
new 71e49adac [AXIOM-506] Partially migrate from DataHandler to Blob
71e49adac is described below
commit 71e49adacd5f9a877fb0895934f5b216921c0c31
Author: Andreas Veithen <andreas.veit...@gmail.com>
AuthorDate: Wed Nov 2 23:12:32 2022 +0000
[AXIOM-506] Partially migrate from DataHandler to Blob
Refactor the DataHandlerProvider, DataHandlerReader and
DataHandlerWriter APIs to work with Blob objects. Also store binary data
as Blob objects internally.
---
.../DataHandlerProvider.java => BlobProvider.java} | 16 ++--
.../DataHandlerReader.java => BlobReader.java} | 33 ++++----
.../DataHandlerWriter.java => BlobWriter.java} | 29 +++----
.../apache/axiom/ext/stax/datahandler/package.html | 25 ------
.../java/org/apache/axiom/ext/stax/package.html | 2 +-
.../java/org/apache/axiom/om/OMCloneOptions.java | 8 +-
.../main/java/org/apache/axiom/om/OMContainer.java | 4 +-
.../java/org/apache/axiom/om/OMDataSource.java | 11 +--
.../main/java/org/apache/axiom/om/OMFactory.java | 9 ++-
.../java/org/apache/axiom/om/OMSerializable.java | 6 +-
.../org/apache/axiom/om/OMXMLBuilderFactory.java | 4 +-
.../apache/axiom/om/impl/MTOMXMLStreamWriter.java | 15 ++--
.../axiom/util/stax/XMLStreamReaderUtils.java | 48 ++++++------
.../axiom/util/stax/XMLStreamWriterUtils.java | 74 +++++++++---------
.../axiom/util/stax/XMLStreamReaderUtilsTest.java | 90 +++++++++++-----------
...der.java => XMLStreamReaderWithBlobReader.java} | 14 ++--
.../om/impl/common/factory/OMFactoryImpl.java | 11 ++-
.../org/apache/axiom/om/impl/intf/TextContent.java | 55 ++++++-------
.../apache/axiom/om/impl/mixin/AxiomTextMixin.java | 3 +-
.../impl/stream/ds/PushOMDataSourceXOPHandler.java | 3 +-
.../pull/AxiomXMLStreamReaderExtensionFactory.java | 6 +-
.../stax/pull/AxiomXMLStreamReaderHelper.java | 26 +++----
...aHandlerReaderImpl.java => BlobReaderImpl.java} | 22 +++---
.../push/AxiomXMLStreamWriterExtensionFactory.java | 6 +-
...aHandlerWriterImpl.java => BlobWriterImpl.java} | 19 +++--
.../stream/stax/push/XMLStreamWriterHandler.java | 32 ++++----
.../om/impl/stream/xop/ContentIDGenerator.java | 2 +-
.../om/impl/stream/xop/OptimizationPolicy.java | 27 +++----
.../om/impl/stream/xop/OptimizationPolicyImpl.java | 7 +-
.../impl/stream/xop/XOPDecodingFilterHandler.java | 10 ++-
.../impl/stream/xop/XOPEncodingFilterHandler.java | 32 ++++----
.../java/org/apache/axiom/samples/LogWriter.java | 14 ++--
.../org/apache/axiom/ts/om/OMTestSuiteBuilder.java | 12 +--
...romElement.java => TestGetBlobFromElement.java} | 12 +--
....java => TestCreateOMTextFromBlobProvider.java} | 29 +++----
.../push/PushOMDataSourceScenario.java | 4 +-
...cenario.java => WriteBlobProviderScenario.java} | 22 +++---
...HandlerScenario.java => WriteBlobScenario.java} | 11 +--
38 files changed, 366 insertions(+), 387 deletions(-)
diff --git
a/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerProvider.java
b/axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobProvider.java
similarity index 74%
rename from
axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerProvider.java
rename to axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobProvider.java
index 09726b833..4b08a457d 100644
---
a/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerProvider.java
+++ b/axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobProvider.java
@@ -17,25 +17,25 @@
* under the License.
*/
-package org.apache.axiom.ext.stax.datahandler;
+package org.apache.axiom.ext.stax;
import java.io.IOException;
-import javax.activation.DataHandler;
+import org.apache.axiom.blob.Blob;
/**
* Interface used for deferred loading of binary content.
*
- * @see DataHandlerReader#isDeferred()
- * @see DataHandlerReader#getDataHandlerProvider()
+ * @see BlobReader#isDeferred()
+ * @see BlobReader#getBlobProvider()
*/
-public interface DataHandlerProvider {
+public interface BlobProvider {
/**
- * Get the {@link DataHandler} object for the binary content.
+ * Get the {@link Blob} object for the binary content.
*
* @return the binary content
*
- * @throws IOException if an error occurs while loading the {@link
DataHandler}
+ * @throws IOException if an error occurs while loading the {@link Blob}
*/
- DataHandler getDataHandler() throws IOException;
+ Blob getBlob() throws IOException;
}
diff --git
a/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerReader.java
b/axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobReader.java
similarity index 85%
rename from
axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerReader.java
rename to axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobReader.java
index 038e5a7ee..d05685560 100644
---
a/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerReader.java
+++ b/axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobReader.java
@@ -17,14 +17,15 @@
* under the License.
*/
-package org.apache.axiom.ext.stax.datahandler;
+package org.apache.axiom.ext.stax;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
+import org.apache.axiom.blob.Blob;
+
/**
* Extension interface for {@link javax.xml.stream.XMLStreamReader}
implementations that expose
- * base64 encoded binary content as {@link DataHandler} objects.
+ * base64 encoded binary content as {@link Blob} objects.
* <p>
* All the requirements specified in {@link org.apache.axiom.ext.stax} apply to
* this extension interface. In particular,
@@ -47,21 +48,21 @@ import javax.xml.stream.XMLStreamException;
* instances provided by databinding frameworks or XMLStreamReader proxies
that enrich a stream of
* StAX events with binary data existing outside of the XML document (e.g. an
XOP/MTOM decoder).
*/
-public interface DataHandlerReader {
+public interface BlobReader {
/**
* The name of the property used to look up this extension interface from a
* {@link javax.xml.stream.XMLStreamReader} implementation.
*/
- String PROPERTY = DataHandlerReader.class.getName();
+ String PROPERTY = BlobReader.class.getName();
/**
* Check whether the current event is a {@link
javax.xml.stream.XMLStreamConstants#CHARACTERS}
* event representing base64 encoded binary content and for which a
- * {@link javax.activation.DataHandler} is available.
+ * {@link Blob} is available.
*
* @return <code>true</code> if the current event is a
* {@link javax.xml.stream.XMLStreamConstants#CHARACTERS} event
representing base64
- * encoded binary content and for which a {@link
javax.activation.DataHandler} is
+ * encoded binary content and for which a {@link Blob} is
* available; <code>false</code> for all other types of events.
*/
boolean isBinary();
@@ -80,8 +81,8 @@ public interface DataHandlerReader {
/**
* Check whether the {@link javax.xml.stream.XMLStreamReader} supports
deferred loading of the
* binary content for the current event. If this method returns
<code>true</code> then a
- * consumer MAY call {@link #getDataHandlerProvider()} and retrieve the
- * {@link javax.activation.DataHandler} later using {@link
DataHandlerProvider#getDataHandler()}.
+ * consumer MAY call {@link #getBlobProvider()} and retrieve the
+ * {@link Blob} later using {@link BlobProvider#getBlob()}.
* Calling this method is only meaningful if {@link #isBinary()} returns
<code>true</code> for
* the current event. The behavior of this method is undefined if this is
not the case.
*
@@ -118,29 +119,29 @@ public interface DataHandlerReader {
String getContentID();
/**
- * Get the {@link DataHandler} with the binary content for the current
event. The behavior of
+ * Get the {@link Blob} with the binary content for the current event. The
behavior of
* this method is only defined for events for which {@link #isBinary()}
returns
* <code>true</code>. For events of this type the method MUST return a
valid
- * {@link DataHandler}, regardless of the return value of {@link
#isDeferred()}. If
+ * {@link Blob}, regardless of the return value of {@link #isDeferred()}.
If
* {@link #isDeferred()} returns <code>true</code>, then the consumer may
use this method to
* force the implementation to load the binary content immediately.
*
* @return the binary content for the current event
*
- * @throws XMLStreamException if an error occurs while loading the {@link
DataHandler}
+ * @throws XMLStreamException if an error occurs while loading the {@link
Blob}
*/
- DataHandler getDataHandler() throws XMLStreamException;
+ Blob getBlob() throws XMLStreamException;
/**
- * Get a {@link DataHandlerProvider} instance for deferred loading of the
binary content for the
+ * Get a {@link BlobProvider} instance for deferred loading of the binary
content for the
* current event. The behavior of this method is defined if and only if
{@link #isDeferred()}
* returns <code>true</code> for the current event. The returned reference
MUST remain valid
* after the current event has been consumed. It is up to the
implementation to specify the
* exact lifecycle of the returned instance, in particular until when the
binary content can be
* retrieved.
*
- * @return the {@link DataHandlerProvider} instance the consumer can use
to load the binary
+ * @return the {@link BlobProvider} instance the consumer can use to load
the binary
* content at a later time
*/
- DataHandlerProvider getDataHandlerProvider();
+ BlobProvider getBlobProvider();
}
diff --git
a/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerWriter.java
b/axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobWriter.java
similarity index 83%
rename from
axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerWriter.java
rename to axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobWriter.java
index 63be94ec8..b60f29aad 100644
---
a/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/DataHandlerWriter.java
+++ b/axiom-api/src/main/java/org/apache/axiom/ext/stax/BlobWriter.java
@@ -17,16 +17,17 @@
* under the License.
*/
-package org.apache.axiom.ext.stax.datahandler;
+package org.apache.axiom.ext.stax;
import java.io.IOException;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
+import org.apache.axiom.blob.Blob;
+
/**
* Extension interface for {@link javax.xml.stream.XMLStreamWriter}
implementations that can
- * receive base64 encoded binary content as {@link DataHandler} objects. A
stream writer
+ * receive base64 encoded binary content as {@link Blob} objects. A stream
writer
* implementing this extension may write the binary data as base64 encoded
character data
* or using some optimization such as XOP/MTOM.
* <p>
@@ -35,8 +36,8 @@ import javax.xml.stream.XMLStreamException;
* a consumer MUST use {@link
javax.xml.stream.XMLStreamWriter#getProperty(String)} with the property
* name defined by {@link #PROPERTY} to get a reference to this extension
interface.
* <p>
- * The interface defines two methods to write binary content, one that takes a
{@link DataHandler}
- * argument and one with a {@link DataHandlerProvider} argument. The first
should be used when
+ * The interface defines two methods to write binary content, one that takes a
{@link Blob}
+ * argument and one with a {@link BlobProvider} argument. The first should be
used when
* the content is immediately available, while the second supports deferred
loading of the data
* handler. The meaning of the <code>contentID</code> and
<code>optimize</code> arguments is
* the same for both methods:
@@ -45,7 +46,7 @@ import javax.xml.stream.XMLStreamException;
* <dd>
* A content ID of the binary content, if available. The semantics of this
argument are
* similar to those defined for the return value of the
- * {@link DataHandlerReader#getContentID()} method:
+ * {@link BlobReader#getContentID()} method:
* <ul>
* <li>This argument should only be set if a content ID has been used
* previously in an interaction with another component or system.
@@ -62,23 +63,23 @@ import javax.xml.stream.XMLStreamException;
* to override this value or ignore it entirely.
* </dl>
* Instead of interacting directly with this extension interface, the consumer
may use the
- * {@link
org.apache.axiom.util.stax.XMLStreamWriterUtils#writeDataHandler(javax.xml.stream.XMLStreamWriter,
DataHandler, String, boolean)} or
- * {@link
org.apache.axiom.util.stax.XMLStreamWriterUtils#writeDataHandler(javax.xml.stream.XMLStreamWriter,
DataHandlerProvider, String, boolean)}
+ * {@link
org.apache.axiom.util.stax.XMLStreamWriterUtils#writeBlob(javax.xml.stream.XMLStreamWriter,
Blob, String, boolean)} or
+ * {@link
org.apache.axiom.util.stax.XMLStreamWriterUtils#writeBlob(javax.xml.stream.XMLStreamWriter,
BlobProvider, String, boolean)}
* utility methods. These methods make the processing of binary data entirely
transparent for
* the caller.
*/
-public interface DataHandlerWriter {
+public interface BlobWriter {
/**
* The name of the property used to look up this extension interface from a
* {@link javax.xml.stream.XMLStreamWriter} implementation.
*/
- String PROPERTY = DataHandlerWriter.class.getName();
+ String PROPERTY = BlobWriter.class.getName();
/**
* Write binary content to the stream. The implementation may choose to
write the data as base64
* encoded character data or using an optimization protocol such as
XOP/MTOM.
*
- * @param dataHandler
+ * @param blob
* the binary content to write
* @param contentID
* an existing content ID for the binary data (see above)
@@ -89,7 +90,7 @@ public interface DataHandlerWriter {
* @throws XMLStreamException
* if an error occurs while writing to the underlying stream
*/
- void writeDataHandler(DataHandler dataHandler, String contentID, boolean
optimize)
+ void writeBlob(Blob blob, String contentID, boolean optimize)
throws IOException, XMLStreamException;
/**
@@ -99,7 +100,7 @@ public interface DataHandlerWriter {
* after the XML infoset is complete. If the caller uses this method, the
implementation can
* defer the actual loading of the binary content.
*
- * @param dataHandlerProvider
+ * @param blobProvider
* the binary content to write
* @param contentID
* an existing content ID for the binary data (see above)
@@ -113,6 +114,6 @@ public interface DataHandlerWriter {
* @throws XMLStreamException
* if an error occurs while writing to the underlying stream
*/
- void writeDataHandler(DataHandlerProvider dataHandlerProvider, String
contentID,
+ void writeBlob(BlobProvider blobProvider, String contentID,
boolean optimize) throws IOException, XMLStreamException;
}
diff --git
a/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/package.html
b/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/package.html
deleted file mode 100644
index a9ccaa432..000000000
--- a/axiom-api/src/main/java/org/apache/axiom/ext/stax/datahandler/package.html
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
- ~ 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.
- -->
-<html>
-<body>
-Defines an Axiom specific extension to the StAX API to work with DataHandler
objects.
-
-@see org.apache.axiom.ext.stax
-</body>
-</html>
\ No newline at end of file
diff --git a/axiom-api/src/main/java/org/apache/axiom/ext/stax/package.html
b/axiom-api/src/main/java/org/apache/axiom/ext/stax/package.html
index 6698fba2d..9724f8318 100644
--- a/axiom-api/src/main/java/org/apache/axiom/ext/stax/package.html
+++ b/axiom-api/src/main/java/org/apache/axiom/ext/stax/package.html
@@ -20,7 +20,7 @@
<body>
Defines Axiom specific extensions to the StAX API.
<p>
-This package and its subpackages defines several extensions to the StAX API,
more precisely for the
+This package defines several extensions to the StAX API, more precisely for the
{@link javax.xml.stream.XMLStreamReader} and {@link
javax.xml.stream.XMLStreamWriter} classes.
The reader or writer wishing to support the
extension MAY implement the corresponding interface directly, but a consumer
MUST use
diff --git a/axiom-api/src/main/java/org/apache/axiom/om/OMCloneOptions.java
b/axiom-api/src/main/java/org/apache/axiom/om/OMCloneOptions.java
index 7c2361e68..7241624c4 100644
--- a/axiom-api/src/main/java/org/apache/axiom/om/OMCloneOptions.java
+++ b/axiom-api/src/main/java/org/apache/axiom/om/OMCloneOptions.java
@@ -20,7 +20,7 @@ package org.apache.axiom.om;
import javax.activation.DataHandler;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.ext.stax.BlobProvider;
public class OMCloneOptions {
private boolean fetchDataHandlers;
@@ -40,11 +40,11 @@ public class OMCloneOptions {
/**
* Specify whether {@link DataHandler} objects should be fetched when
cloning {@link OMText}
* nodes. If this option is set to <code>false</code> (default) then an
{@link OMText} node
- * backed by a {@link DataHandlerProvider} will be cloned by copying the
reference to that
- * {@link DataHandlerProvider} to the cloned {@link OMText} node. This
implies that if the
+ * backed by a {@link BlobProvider} will be cloned by copying the
reference to that
+ * {@link BlobProvider} to the cloned {@link OMText} node. This implies
that if the
* original tree was constructed from an XOP encoded stream, then the
clone may become unusable
* if that stream is closed. If this option is set to <code>true</code>,
then
- * {@link DataHandlerProvider} references will be replaced by {@link
DataHandler} references. In
+ * {@link BlobProvider} references will be replaced by {@link DataHandler}
references. In
* addition, the necessary actions are taken to ensure that the content of
these
* {@link DataHandler} instances is fetched into memory or temporary
storage, so that the clones
* remain usable even after the underlying stream is closed.
diff --git a/axiom-api/src/main/java/org/apache/axiom/om/OMContainer.java
b/axiom-api/src/main/java/org/apache/axiom/om/OMContainer.java
index d8c59683e..812ea178b 100644
--- a/axiom-api/src/main/java/org/apache/axiom/om/OMContainer.java
+++ b/axiom-api/src/main/java/org/apache/axiom/om/OMContainer.java
@@ -26,7 +26,7 @@ import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.sax.SAXSource;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerReader;
+import org.apache.axiom.ext.stax.BlobReader;
import org.xml.sax.ContentHandler;
import org.xml.sax.DTDHandler;
import org.xml.sax.ext.DeclHandler;
@@ -315,7 +315,7 @@ public interface OMContainer extends OMSerializable {
* {@link XMLStreamReader#close()} method.
* <p>
* The returned reader MAY implement the extension defined by
- * {@link DataHandlerReader} and any binary content will
+ * {@link BlobReader} and any binary content will
* be reported using this extension. More precisely, if the object model
contains an
* {@link OMText} instance with {@link OMText#isBinary()} returning
<code>true</code> (or
* would contain such an instance after it has been fully built), then its
data will always be
diff --git a/axiom-api/src/main/java/org/apache/axiom/om/OMDataSource.java
b/axiom-api/src/main/java/org/apache/axiom/om/OMDataSource.java
index 7d6db4bac..50e353262 100644
--- a/axiom-api/src/main/java/org/apache/axiom/om/OMDataSource.java
+++ b/axiom-api/src/main/java/org/apache/axiom/om/OMDataSource.java
@@ -27,8 +27,9 @@ import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.blob.Blob;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobWriter;
import org.apache.axiom.om.ds.AbstractOMDataSource;
import org.apache.axiom.om.ds.AbstractPullOMDataSource;
import org.apache.axiom.om.ds.AbstractPushOMDataSource;
@@ -122,10 +123,10 @@ public interface OMDataSource {
* <li>To produce base64 binary data (that could be optimized using
XOP/MTOM), the
* implementation MUST use one of the following approaches:
* <ul>
- * <li>Use the {@link DataHandlerWriter} extension (or alternatively the
- * {@link XMLStreamWriterUtils#writeDataHandler(XMLStreamWriter,
DataHandler, String, boolean)}
+ * <li>Use the {@link BlobWriter} extension (or alternatively the
+ * {@link XMLStreamWriterUtils#writeBlob(XMLStreamWriter, Blob, String,
boolean)}
* or
- * {@link XMLStreamWriterUtils#writeDataHandler(XMLStreamWriter,
DataHandlerProvider, String, boolean)}
+ * {@link XMLStreamWriterUtils#writeBlob(XMLStreamWriter, BlobProvider,
String, boolean)}
* utility methods) to write the data to the stream. This is the preferred
approach, unless the
* content is produced by a third party library that is not aware of these
APIs.
* <li>Cast the {@link XMLStreamWriter} to an {@link MTOMXMLStreamWriter},
use
diff --git a/axiom-api/src/main/java/org/apache/axiom/om/OMFactory.java
b/axiom-api/src/main/java/org/apache/axiom/om/OMFactory.java
index 34e4bc232..e6541afe4 100644
--- a/axiom-api/src/main/java/org/apache/axiom/om/OMFactory.java
+++ b/axiom-api/src/main/java/org/apache/axiom/om/OMFactory.java
@@ -22,7 +22,8 @@ package org.apache.axiom.om;
import javax.activation.DataHandler;
import javax.xml.namespace.QName;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.blob.Blob;
+import org.apache.axiom.ext.stax.BlobProvider;
/** Class OMFactory */
public interface OMFactory {
@@ -300,14 +301,14 @@ public interface OMFactory {
*
* @param contentID
* the content ID identifying the binary content; may be
<code>null</code>
- * @param dataHandlerProvider
- * used to load the {@link javax.activation.DataHandler} when
requested from the returned
+ * @param blobProvider
+ * used to load the {@link Blob} when requested from the
returned
* {@link OMText} node
* @param optimize
* determines whether the binary content should be optimized
* @return TODO
*/
- OMText createOMText(String contentID, DataHandlerProvider
dataHandlerProvider,
+ OMText createOMText(String contentID, BlobProvider blobProvider,
boolean optimize);
/**
diff --git a/axiom-api/src/main/java/org/apache/axiom/om/OMSerializable.java
b/axiom-api/src/main/java/org/apache/axiom/om/OMSerializable.java
index ed4122b7f..73bfc2872 100644
--- a/axiom-api/src/main/java/org/apache/axiom/om/OMSerializable.java
+++ b/axiom-api/src/main/java/org/apache/axiom/om/OMSerializable.java
@@ -22,7 +22,7 @@ package org.apache.axiom.om;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.ext.stax.BlobWriter;
/**
* Information item that can be serialized (written to an XML stream writer)
and
@@ -85,11 +85,11 @@ public interface OMSerializable extends OMInformationItem {
* <p>
* The implementation of this method must satisfy the following
requirements:
* <ul>
- * <li>If the writer exposes the {@link DataHandlerWriter} extension, then
base64 binary data
+ * <li>If the writer exposes the {@link BlobWriter} extension, then base64
binary data
* MUST be written using one of the methods defined by that extension.
This will occur if the
* information item is an {@link OMText} node for which {@link
OMText#isBinary()} returns
* <code>true</code> or if it is an {@link OMContainer} that has such an
{@link OMText} node as
- * descendant. If the writer doesn't expose the {@link DataHandlerWriter}
extension, then the
+ * descendant. If the writer doesn't expose the {@link BlobWriter}
extension, then the
* implementation MUST use {@link XMLStreamWriter#writeCharacters(String)}
or
* {@link XMLStreamWriter#writeCharacters(char[], int, int)} to write the
base64 encoded data to
* the stream.
diff --git
a/axiom-api/src/main/java/org/apache/axiom/om/OMXMLBuilderFactory.java
b/axiom-api/src/main/java/org/apache/axiom/om/OMXMLBuilderFactory.java
index da4575cce..0d4261d6e 100644
--- a/axiom-api/src/main/java/org/apache/axiom/om/OMXMLBuilderFactory.java
+++ b/axiom-api/src/main/java/org/apache/axiom/om/OMXMLBuilderFactory.java
@@ -29,7 +29,7 @@ import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXSource;
import org.apache.axiom.attachments.Attachments;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerReader;
+import org.apache.axiom.ext.stax.BlobReader;
import org.apache.axiom.mime.ContentType;
import org.apache.axiom.mime.MediaType;
import org.apache.axiom.mime.MultipartBody;
@@ -68,7 +68,7 @@ public class OMXMLBuilderFactory {
* of the document represented by the stream reader.
* <p>
* The builder supports the {@link XMLStreamReader} extension defined by
- * {@link DataHandlerReader} as well as the legacy extension mechanism
defined in the
+ * {@link BlobReader} as well as the legacy extension mechanism defined in
the
* documentation of {@link XMLStreamReaderUtils}.
* <p>
* The returned builder also performs namespace repairing, i.e. it adds
appropriate namespace
diff --git
a/axiom-api/src/main/java/org/apache/axiom/om/impl/MTOMXMLStreamWriter.java
b/axiom-api/src/main/java/org/apache/axiom/om/impl/MTOMXMLStreamWriter.java
index b7b49b0bf..a7bd1cf27 100644
--- a/axiom-api/src/main/java/org/apache/axiom/om/impl/MTOMXMLStreamWriter.java
+++ b/axiom-api/src/main/java/org/apache/axiom/om/impl/MTOMXMLStreamWriter.java
@@ -25,8 +25,9 @@ import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.blob.Blob;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobWriter;
import org.apache.axiom.om.OMOutputFormat;
import org.apache.axiom.util.stax.XMLStreamWriterUtils;
@@ -42,9 +43,9 @@ public abstract class MTOMXMLStreamWriter implements
XMLStreamWriter {
* Check if MTOM is enabled.
* <p>
* Note that serialization code should use
- * {@link XMLStreamWriterUtils#writeDataHandler(XMLStreamWriter,
DataHandler, String, boolean)}
+ * {@link XMLStreamWriterUtils#writeBlob(XMLStreamWriter, Blob, String,
boolean)}
* or
- * {@link XMLStreamWriterUtils#writeDataHandler(XMLStreamWriter,
DataHandlerProvider, String, boolean)}
+ * {@link XMLStreamWriterUtils#writeBlob(XMLStreamWriter, BlobProvider,
String, boolean)}
* to submit any binary content and let this writer decide whether the
content should be written
* as base64 encoded character data or using {@code xop:Include}. This
makes optimization
* entirely transparent for the caller and there should be no need to
check if the writer is
@@ -59,7 +60,7 @@ public abstract class MTOMXMLStreamWriter implements
XMLStreamWriter {
public abstract boolean isOptimized();
/**
- * Prepare a {@link DataHandler} for serialization without using the
{@link DataHandlerWriter}
+ * Prepare a {@link DataHandler} for serialization without using the
{@link BlobWriter}
* API. The method first determines whether the binary data represented by
the
* {@link DataHandler} should be optimized or inlined. If the data should
not be optimized, then
* the method returns <code>null</code> and the caller is expected to use
@@ -70,9 +71,9 @@ public abstract class MTOMXMLStreamWriter implements
XMLStreamWriter {
* <p>
* This method should only be used to integrate Axiom with third party
libraries that support
* XOP. In all other cases,
- * {@link XMLStreamWriterUtils#writeDataHandler(XMLStreamWriter,
DataHandler, String, boolean)}
+ * {@link XMLStreamWriterUtils#writeBlob(XMLStreamWriter, Blob, String,
boolean)}
* or
- * {@link XMLStreamWriterUtils#writeDataHandler(XMLStreamWriter,
DataHandlerProvider, String, boolean)}
+ * {@link XMLStreamWriterUtils#writeBlob(XMLStreamWriter, BlobProvider,
String, boolean)}
* should be used to write base64Binary values and the application code
should never generate
* {@code xop:Include} elements itself.
*
diff --git
a/axiom-api/src/main/java/org/apache/axiom/util/stax/XMLStreamReaderUtils.java
b/axiom-api/src/main/java/org/apache/axiom/util/stax/XMLStreamReaderUtils.java
index 966d20246..b0f867695 100644
---
a/axiom-api/src/main/java/org/apache/axiom/util/stax/XMLStreamReaderUtils.java
+++
b/axiom-api/src/main/java/org/apache/axiom/util/stax/XMLStreamReaderUtils.java
@@ -23,25 +23,23 @@ import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
+import org.apache.axiom.blob.Blob;
import org.apache.axiom.blob.Blobs;
import org.apache.axiom.blob.MemoryBlob;
+import org.apache.axiom.ext.stax.BlobReader;
import org.apache.axiom.ext.stax.CharacterDataReader;
import org.apache.axiom.ext.stax.DelegatingXMLStreamReader;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerReader;
-import org.apache.axiom.util.activation.BlobDataSource;
-import org.apache.axiom.util.activation.EmptyDataSource;
import org.apache.axiom.util.base64.Base64DecodingOutputStreamWriter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Contains utility methods to work with {@link XMLStreamReader} objects,
including the extension
- * defined by {@link DataHandlerReader}.
+ * defined by {@link BlobReader}.
*/
public class XMLStreamReaderUtils {
private static final Log log =
LogFactory.getLog(XMLStreamReaderUtils.class);
@@ -49,18 +47,18 @@ public class XMLStreamReaderUtils {
private XMLStreamReaderUtils() {}
/**
- * Get the {@link DataHandlerReader} extension for a given {@link
XMLStreamReader}, if
+ * Get the {@link BlobReader} extension for a given {@link
XMLStreamReader}, if
* available.
*
* @param reader
- * the stream reader to get the {@link DataHandlerReader}
extension from
+ * the stream reader to get the {@link BlobReader} extension
from
* @return the implementation of the extension, or <code>null</code> if the
* {@link XMLStreamReader} doesn't expose base64 encoded binary
content as
- * {@link DataHandler} objects.
+ * {@link Blob} objects.
*/
- public static DataHandlerReader getDataHandlerReader(final XMLStreamReader
reader) {
+ public static BlobReader getBlobReader(final XMLStreamReader reader) {
try {
- return
(DataHandlerReader)reader.getProperty(DataHandlerReader.PROPERTY);
+ return (BlobReader)reader.getProperty(BlobReader.PROPERTY);
} catch (IllegalArgumentException ex) {
return null;
}
@@ -68,21 +66,21 @@ public class XMLStreamReaderUtils {
/**
* Helper method to implement {@link XMLStreamReader#getProperty(String)}.
This method
- * processes the property defined by {@link DataHandlerReader#PROPERTY}.
+ * processes the property defined by {@link BlobReader#PROPERTY}.
*
* @param extension
- * the reference to the {@link DataHandlerReader} extension for
the
+ * the reference to the {@link BlobReader} extension for the
* {@link XMLStreamReader} implementation
* @param propertyName
* the name of the property, as passed to the
* {@link XMLStreamReader#getProperty(String)} method
- * @return the property value as specified by the {@link
DataHandlerReader} extension;
+ * @return the property value as specified by the {@link BlobReader}
extension;
* <code>null</code> if the property doesn't match
*/
- public static Object processGetProperty(DataHandlerReader extension,
String propertyName) {
+ public static Object processGetProperty(BlobReader extension, String
propertyName) {
if (extension == null || propertyName == null) {
throw new IllegalArgumentException();
- } else if (propertyName.equals(DataHandlerReader.PROPERTY)) {
+ } else if (propertyName.equals(BlobReader.PROPERTY)) {
return extension;
} else {
return null;
@@ -90,9 +88,9 @@ public class XMLStreamReaderUtils {
}
/**
- * Get a {@link DataHandler} for the binary data encoded in an element.
The method supports
+ * Get a {@link Blob} for the binary data encoded in an element. The
method supports
* base64 encoded character data as well as optimized binary data through
the
- * {@link DataHandlerReader} extension.
+ * {@link BlobReader} extension.
* <p>
* <em>Precondition</em>: the reader is on a {@link
XMLStreamConstants#START_ELEMENT}
* <p>
@@ -102,21 +100,21 @@ public class XMLStreamReaderUtils {
* @param reader the stream to read the data from
* @return the binary data from the element
*/
- public static DataHandler getDataHandlerFromElement(XMLStreamReader reader)
+ public static Blob getBlobFromElement(XMLStreamReader reader)
throws XMLStreamException {
int event = reader.next();
if (event == XMLStreamConstants.END_ELEMENT) {
- // This means that the element is actually empty -> return empty
DataHandler
- return new DataHandler(new
EmptyDataSource("application/octet-stream"));
+ // This means that the element is actually empty -> return empty
blob
+ return Blobs.createBlob(new byte[0]);
} else if (event != XMLStreamConstants.CHARACTERS) {
throw new XMLStreamException("Expected a CHARACTER event");
}
- DataHandlerReader dhr = getDataHandlerReader(reader);
- if (dhr != null && dhr.isBinary()) {
- DataHandler dh = dhr.getDataHandler();
+ BlobReader blobReader = getBlobReader(reader);
+ if (blobReader != null && blobReader.isBinary()) {
+ Blob blob = blobReader.getBlob();
reader.next();
- return dh;
+ return blob;
} else {
MemoryBlob blob = Blobs.createMemoryBlob();
Writer out = new
Base64DecodingOutputStreamWriter(blob.getOutputStream());
@@ -139,7 +137,7 @@ public class XMLStreamReaderUtils {
} catch (IOException ex) {
throw new XMLStreamException("Error during base64 decoding",
ex);
}
- return new DataHandler(new BlobDataSource(blob,
"application/octet-string"));
+ return blob;
}
}
diff --git
a/axiom-api/src/main/java/org/apache/axiom/util/stax/XMLStreamWriterUtils.java
b/axiom-api/src/main/java/org/apache/axiom/util/stax/XMLStreamWriterUtils.java
index 93e9edcf2..1525c1bcb 100644
---
a/axiom-api/src/main/java/org/apache/axiom/util/stax/XMLStreamWriterUtils.java
+++
b/axiom-api/src/main/java/org/apache/axiom/util/stax/XMLStreamWriterUtils.java
@@ -21,12 +21,12 @@ package org.apache.axiom.util.stax;
import java.io.IOException;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.blob.Blob;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobWriter;
import org.apache.axiom.util.base64.Base64EncodingWriterOutputStream;
/**
@@ -43,68 +43,68 @@ public class XMLStreamWriterUtils {
* <p>
* Note that this method will always serialize the data as base64 encoded
character data.
* Serialization code should prefer using
- * {@link #writeDataHandler(XMLStreamWriter, DataHandler, String,
boolean)} or
- * {@link #writeDataHandler(XMLStreamWriter, DataHandlerProvider, String,
boolean)} to
+ * {@link #writeBlob(XMLStreamWriter, Blob, String, boolean)} or
+ * {@link #writeBlob(XMLStreamWriter, BlobProvider, String, boolean)} to
* enable optimization (if supported by the {@link XMLStreamWriter}).
*
* @param writer the stream writer to write the data to
- * @param dh the data handler containing the data to encode
+ * @param blob the blob containing the data to encode
* @throws IOException if an error occurs when reading the data from the
data handler
* @throws XMLStreamException if an error occurs when writing the base64
encoded data to
* the stream
*/
- public static void writeBase64(XMLStreamWriter writer, DataHandler dh)
+ public static void writeBase64(XMLStreamWriter writer, Blob blob)
throws IOException, XMLStreamException {
Base64EncodingWriterOutputStream out = new
Base64EncodingWriterOutputStream(
new XMLStreamWriterWriter(writer), 4096, true);
try {
- dh.writeTo(out);
+ blob.writeTo(out);
out.close();
} catch (XMLStreamIOException ex) {
throw ex.getXMLStreamException();
}
}
- private static DataHandlerWriter
internalGetDataHandlerWriter(XMLStreamWriter writer) {
+ private static BlobWriter internalGetBlobWriter(XMLStreamWriter writer) {
try {
- return
(DataHandlerWriter)writer.getProperty(DataHandlerWriter.PROPERTY);
+ return (BlobWriter)writer.getProperty(BlobWriter.PROPERTY);
} catch (IllegalArgumentException ex) {
return null;
}
}
/**
- * Get the {@link DataHandlerWriter} extension for a given {@link
XMLStreamWriter}. If the
+ * Get the {@link BlobWriter} extension for a given {@link
XMLStreamWriter}. If the
* writer exposes the extension, a reference to the extension interface
implementation is
* returned. If the writer doesn't expose the extension, this method
returns an instance of the
* extension interface that emulates the extension (by writing the binary
data as base64
* character data to the stream).
*
* @param writer
- * the stream for which the method should return the {@link
DataHandlerWriter}
+ * the stream for which the method should return the {@link
BlobWriter}
* extension
* @return a reference to the extension interface exposed by the writer or
an implementation the
* emulates the extension; the return value is never
<code>null</code>
*/
- public static DataHandlerWriter getDataHandlerWriter(final XMLStreamWriter
writer) {
- DataHandlerWriter dataHandlerWriter =
internalGetDataHandlerWriter(writer);
- if (dataHandlerWriter == null) {
- return new DataHandlerWriter() {
+ public static BlobWriter getBlobWriter(final XMLStreamWriter writer) {
+ BlobWriter blobWriter = internalGetBlobWriter(writer);
+ if (blobWriter == null) {
+ return new BlobWriter() {
@Override
- public void writeDataHandler(DataHandler dataHandler, String
contentID,
+ public void writeBlob(Blob blob, String contentID,
boolean optimize) throws IOException,
XMLStreamException {
- writeBase64(writer, dataHandler);
+ writeBase64(writer, blob);
}
@Override
- public void writeDataHandler(DataHandlerProvider
dataHandlerProvider,
+ public void writeBlob(BlobProvider blobProvider,
String contentID, boolean optimize) throws
IOException, XMLStreamException {
- writeBase64(writer, dataHandlerProvider.getDataHandler());
+ writeBase64(writer, blobProvider.getBlob());
}
};
} else {
- return dataHandlerWriter;
+ return blobWriter;
}
}
@@ -112,15 +112,15 @@ public class XMLStreamWriterUtils {
* Write binary content to the stream. Depending on the supplied {@link
XMLStreamWriter},
* the content will be written as base64 encoded character data or using
an optimization
* scheme such as XOP/MTOM. The method attempts to submit the binary
content using the
- * {@link DataHandlerWriter} extension. If the writer doesn't expose this
extension,
- * the method will fall back to {@link #writeBase64(XMLStreamWriter,
DataHandler)}.
+ * {@link BlobWriter} extension. If the writer doesn't expose this
extension,
+ * the method will fall back to {@link #writeBase64(XMLStreamWriter,
Blob)}.
* <p>
- * Please refer to the documentation of {@link DataHandlerWriter} for a
more
+ * Please refer to the documentation of {@link BlobWriter} for a more
* detailed description of the semantics of the different arguments.
*
* @param writer
* the stream writer to write the data to
- * @param dataHandler
+ * @param blob
* the binary content to write
* @param contentID
* an existing content ID for the binary data
@@ -131,24 +131,24 @@ public class XMLStreamWriterUtils {
* @throws XMLStreamException
* if an error occurs while writing to the underlying stream
*/
- public static void writeDataHandler(XMLStreamWriter writer, DataHandler
dataHandler,
+ public static void writeBlob(XMLStreamWriter writer, Blob blob,
String contentID, boolean optimize) throws IOException,
XMLStreamException {
- DataHandlerWriter dataHandlerWriter =
internalGetDataHandlerWriter(writer);
- if (dataHandlerWriter != null) {
- dataHandlerWriter.writeDataHandler(dataHandler, contentID,
optimize);
+ BlobWriter blobWriter = internalGetBlobWriter(writer);
+ if (blobWriter != null) {
+ blobWriter.writeBlob(blob, contentID, optimize);
} else {
- writeBase64(writer, dataHandler);
+ writeBase64(writer, blob);
}
}
/**
* Write binary content to the stream. This method is similar to
- * {@link #writeDataHandler(XMLStreamWriter, DataHandler, String,
boolean)},
+ * {@link #writeBlob(XMLStreamWriter, Blob, String, boolean)},
* but supports deferred loading of the data handler.
*
* @param writer
* the stream writer to write the data to
- * @param dataHandlerProvider
+ * @param blobProvider
* the binary content to write
* @param contentID
* an existing content ID for the binary data
@@ -159,13 +159,13 @@ public class XMLStreamWriterUtils {
* @throws XMLStreamException
* if an error occurs while writing to the underlying stream
*/
- public static void writeDataHandler(XMLStreamWriter writer,
DataHandlerProvider dataHandlerProvider,
+ public static void writeBlob(XMLStreamWriter writer, BlobProvider
blobProvider,
String contentID, boolean optimize) throws IOException,
XMLStreamException {
- DataHandlerWriter dataHandlerWriter =
internalGetDataHandlerWriter(writer);
- if (dataHandlerWriter != null) {
- dataHandlerWriter.writeDataHandler(dataHandlerProvider, contentID,
optimize);
+ BlobWriter blobWriter = internalGetBlobWriter(writer);
+ if (blobWriter != null) {
+ blobWriter.writeBlob(blobProvider, contentID, optimize);
} else {
- writeBase64(writer, dataHandlerProvider.getDataHandler());
+ writeBase64(writer, blobProvider.getBlob());
}
}
diff --git
a/axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderUtilsTest.java
b/axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderUtilsTest.java
index 4eee156f5..32183945b 100644
---
a/axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderUtilsTest.java
+++
b/axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderUtilsTest.java
@@ -24,12 +24,12 @@ import java.io.StringReader;
import java.util.Arrays;
import java.util.Random;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import junit.framework.TestCase;
+import org.apache.axiom.blob.Blob;
import org.apache.axiom.om.util.StAXParserConfiguration;
import org.apache.axiom.om.util.StAXUtils;
import org.apache.axiom.util.base64.Base64EncodingStringBufferOutputStream;
@@ -37,33 +37,33 @@ import org.apache.commons.io.IOUtils;
public class XMLStreamReaderUtilsTest extends TestCase {
/**
- * Test that {@link
XMLStreamReaderUtils#getDataHandlerFromElement(XMLStreamReader)}
- * returns an empty {@link DataHandler} when the element is empty. The
test uses
+ * Test that {@link
XMLStreamReaderUtils#getBlobFromElement(XMLStreamReader)}
+ * returns an empty {@link Blob} when the element is empty. The test uses
* an {@link XMLStreamReader} instance that doesn't implement the
- * {@link org.apache.axiom.ext.stax.datahandler.DataHandlerReader}
extension.
+ * {@link org.apache.axiom.ext.stax.BlobReader} extension.
*
* @throws Exception
*/
- public void testGetDataHandlerFromElementWithZeroLengthNonDHR() throws
Exception {
- testGetDataHandlerFromElementWithZeroLength(false);
+ public void testGetBlobFromElementWithZeroLengthNonBlobReader() throws
Exception {
+ testGetBlobFromElementWithZeroLength(false);
}
/**
- * Test that {@link
XMLStreamReaderUtils#getDataHandlerFromElement(XMLStreamReader)}
- * returns an empty {@link DataHandler} when the element is empty. The
test uses
+ * Test that {@link
XMLStreamReaderUtils#getBlobFromElement(XMLStreamReader)}
+ * returns an empty {@link Blob} when the element is empty. The test uses
* an {@link XMLStreamReader} instance that implements the
- * {@link org.apache.axiom.ext.stax.datahandler.DataHandlerReader}
extension.
+ * {@link org.apache.axiom.ext.stax.BlobReader} extension.
*
* @throws Exception
*/
- public void testGetDataHandlerFromElementWithZeroLengthDHR() throws
Exception {
- testGetDataHandlerFromElementWithZeroLength(true);
+ public void testGetBlobFromElementWithZeroLengthBlobReader() throws
Exception {
+ testGetBlobFromElementWithZeroLength(true);
}
- private void testGetDataHandlerFromElementWithZeroLength(boolean useDHR)
throws Exception {
+ private void testGetBlobFromElementWithZeroLength(boolean useBlobReader)
throws Exception {
XMLStreamReader reader = StAXUtils.createXMLStreamReader(new
StringReader("<test/>"));
- if (useDHR) {
- reader = new XMLStreamReaderWithDataHandlerReader(reader);
+ if (useBlobReader) {
+ reader = new XMLStreamReaderWithBlobReader(reader);
}
try {
reader.next();
@@ -71,44 +71,44 @@ public class XMLStreamReaderUtilsTest extends TestCase {
// Check precondition
assertTrue(reader.isStartElement());
- DataHandler dh =
XMLStreamReaderUtils.getDataHandlerFromElement(reader);
+ Blob blob = XMLStreamReaderUtils.getBlobFromElement(reader);
// Check postcondition
assertTrue(reader.isEndElement());
- assertEquals(-1, dh.getInputStream().read());
+ assertEquals(-1, blob.getInputStream().read());
} finally {
reader.close();
}
}
/**
- * Test that {@link
XMLStreamReaderUtils#getDataHandlerFromElement(XMLStreamReader)}
+ * Test that {@link
XMLStreamReaderUtils#getBlobFromElement(XMLStreamReader)}
* throws an exception if the element has unexpected content. The test uses
* an {@link XMLStreamReader} instance that doesn't implement the
- * {@link org.apache.axiom.ext.stax.datahandler.DataHandlerReader}
extension.
+ * {@link org.apache.axiom.ext.stax.BlobReader} extension.
*
* @throws Exception
*/
- public void testGetDataHandlerFromElementWithUnexpectedContentNonDHR()
throws Exception {
- testGetDataHandlerFromElementWithUnexpectedContent(false);
+ public void testGetBlobFromElementWithUnexpectedContentNonBlobReader()
throws Exception {
+ testGetBlobFromElementWithUnexpectedContent(false);
}
/**
- * Test that {@link
XMLStreamReaderUtils#getDataHandlerFromElement(XMLStreamReader)}
+ * Test that {@link
XMLStreamReaderUtils#getBlobFromElement(XMLStreamReader)}
* throws an exception if the element has unexpected content. The test uses
* an {@link XMLStreamReader} instance that implements the
- * {@link org.apache.axiom.ext.stax.datahandler.DataHandlerReader}
extension.
+ * {@link org.apache.axiom.ext.stax.BlobReader} extension.
*
* @throws Exception
*/
- public void testGetDataHandlerFromElementWithUnexpectedContentDHR() throws
Exception {
- testGetDataHandlerFromElementWithUnexpectedContent(true);
+ public void testGetBlobFromElementWithUnexpectedContentBlobReader() throws
Exception {
+ testGetBlobFromElementWithUnexpectedContent(true);
}
- private void testGetDataHandlerFromElementWithUnexpectedContent(boolean
useDHR) throws Exception {
+ private void testGetBlobFromElementWithUnexpectedContent(boolean
useBlobReader) throws Exception {
XMLStreamReader reader = StAXUtils.createXMLStreamReader(new
StringReader("<test>\n<child/>\n</test>"));
- if (useDHR) {
- reader = new XMLStreamReaderWithDataHandlerReader(reader);
+ if (useBlobReader) {
+ reader = new XMLStreamReaderWithBlobReader(reader);
}
try {
reader.next();
@@ -117,7 +117,7 @@ public class XMLStreamReaderUtilsTest extends TestCase {
assertTrue(reader.isStartElement());
try {
- XMLStreamReaderUtils.getDataHandlerFromElement(reader);
+ XMLStreamReaderUtils.getBlobFromElement(reader);
fail("Expected XMLStreamException");
} catch (XMLStreamException ex) {
// Expected
@@ -128,32 +128,32 @@ public class XMLStreamReaderUtilsTest extends TestCase {
}
/**
- * Test that {@link
XMLStreamReaderUtils#getDataHandlerFromElement(XMLStreamReader)}
+ * Test that {@link
XMLStreamReaderUtils#getBlobFromElement(XMLStreamReader)}
* correctly decodes base64 data if the parser is non coalescing and
produces the data
* as multiple {@code CHARACTER} events. The test uses an {@link
XMLStreamReader} instance
- * that doesn't implement the {@link
org.apache.axiom.ext.stax.datahandler.DataHandlerReader}
+ * that doesn't implement the {@link org.apache.axiom.ext.stax.BlobReader}
* extension.
*
* @throws Exception
*/
- public void testGetDataHandlerFromElementNonCoalescingNonDHR() throws
Exception {
- testGetDataHandlerFromElementNonCoalescing(false);
+ public void testgetBlobFromElementNonCoalescingNonBlobReader() throws
Exception {
+ testgetBlobFromElementNonCoalescing(false);
}
/**
- * Test that {@link
XMLStreamReaderUtils#getDataHandlerFromElement(XMLStreamReader)}
+ * Test that {@link
XMLStreamReaderUtils#getBlobFromElement(XMLStreamReader)}
* correctly decodes base64 data if the parser is non coalescing and
produces the data
* as multiple {@code CHARACTER} events. The test uses an {@link
XMLStreamReader} instance
- * that implements the {@link
org.apache.axiom.ext.stax.datahandler.DataHandlerReader}
+ * that implements the {@link org.apache.axiom.ext.stax.BlobReader}
* extension.
*
* @throws Exception
*/
- public void testGetDataHandlerFromElementNonCoalescingDHR() throws
Exception {
- testGetDataHandlerFromElementNonCoalescing(true);
+ public void testgetBlobFromElementNonCoalescingBlobReader() throws
Exception {
+ testgetBlobFromElementNonCoalescing(true);
}
- private void testGetDataHandlerFromElementNonCoalescing(boolean useDHR)
throws Exception {
+ private void testgetBlobFromElementNonCoalescing(boolean useBlobReader)
throws Exception {
// We generate base64 that is sufficiently large to force the parser
to generate
// multiple CHARACTER events
StringBuffer buffer = new StringBuffer("<test>");
@@ -165,8 +165,8 @@ public class XMLStreamReaderUtilsTest extends TestCase {
buffer.append("</test>");
XMLStreamReader reader =
StAXUtils.createXMLStreamReader(StAXParserConfiguration.NON_COALESCING,
new StringReader(buffer.toString()));
- if (useDHR) {
- reader = new XMLStreamReaderWithDataHandlerReader(reader);
+ if (useBlobReader) {
+ reader = new XMLStreamReaderWithBlobReader(reader);
}
try {
reader.next();
@@ -174,33 +174,33 @@ public class XMLStreamReaderUtilsTest extends TestCase {
// Check precondition
assertTrue(reader.isStartElement());
- DataHandler dh =
XMLStreamReaderUtils.getDataHandlerFromElement(reader);
+ Blob blob = XMLStreamReaderUtils.getBlobFromElement(reader);
// Check postcondition
assertTrue(reader.isEndElement());
- assertTrue(Arrays.equals(data,
IOUtils.toByteArray(dh.getInputStream())));
+ assertTrue(Arrays.equals(data,
IOUtils.toByteArray(blob.getInputStream())));
} finally {
reader.close();
}
}
/**
- * Test that {@link
XMLStreamReaderUtils#getDataHandlerFromElement(XMLStreamReader)} correctly
+ * Test that {@link
XMLStreamReaderUtils#getBlobFromElement(XMLStreamReader)} correctly
* decodes base64 encoded content that contains whitespace. This is a
regression test for <a
* href="https://issues.apache.org/jira/browse/AXIOM-380";>AXIOM-380</a>.
*
* @throws Exception
*/
- public void testGetDataHandlerFromElementWithWhitespace() throws Exception
{
+ public void testgetBlobFromElementWithWhitespace() throws Exception {
XMLStreamReader reader = StAXUtils.createXMLStreamReader(new
StringReader(
"<data>MS4wMToxNDIdMS4wMjowMzAwHTEuMDM6MR8wMx4yHzAwHjQfMDEeNB8wMh0xLjA0OlBOUx0xLjA1\r\n"
+
"OjIwMTEwODAyHTEuMDY6Mh0xLjA3OkZMRkRMRUNWWh0xLjA4OkZMMDM3ODhXMB0xLjA5OjExMDgw\r\n"
+
"MjAwMDcdMS4xMToxOS42OR0xLjEyOjE5LjY5HDIuMDAxOjE4HTIuMDAyOjAwHAAA</data>"));
try {
reader.next();
- DataHandler dh =
XMLStreamReaderUtils.getDataHandlerFromElement(reader);
+ Blob blob = XMLStreamReaderUtils.getBlobFromElement(reader);
assertEquals("1.01:142 1.02:0300 1.03:1 03 2 00 4 01 4 02 1.04:PNS 1.05:20110802 1.06:2 1.07:FLFDLECVZ 1.08:FL03788W0 1.09:1108020007 1.11:19.69 1.12:19.69 2.001:18 2.002:00 ����",
- IOUtils.toString(dh.getInputStream(), "ascii"));
+ IOUtils.toString(blob.getInputStream(), "ascii"));
} finally {
reader.close();
}
diff --git
a/axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderWithDataHandlerReader.java
b/axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderWithBlobReader.java
similarity index 78%
rename from
axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderWithDataHandlerReader.java
rename to
axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderWithBlobReader.java
index 87dc28929..371795c84 100644
---
a/axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderWithDataHandlerReader.java
+++
b/axiom-api/src/test/java/org/apache/axiom/util/stax/XMLStreamReaderWithBlobReader.java
@@ -18,16 +18,16 @@
*/
package org.apache.axiom.util.stax;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerReader;
+import org.apache.axiom.blob.Blob;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobReader;
import org.apache.axiom.util.stax.wrapper.XMLStreamReaderWrapper;
-public class XMLStreamReaderWithDataHandlerReader extends
XMLStreamReaderWrapper implements DataHandlerReader {
- public XMLStreamReaderWithDataHandlerReader(XMLStreamReader parent) {
+public class XMLStreamReaderWithBlobReader extends XMLStreamReaderWrapper
implements BlobReader {
+ public XMLStreamReaderWithBlobReader(XMLStreamReader parent) {
super(parent);
}
@@ -58,12 +58,12 @@ public class XMLStreamReaderWithDataHandlerReader extends
XMLStreamReaderWrapper
}
@Override
- public DataHandler getDataHandler() throws XMLStreamException {
+ public Blob getBlob() throws XMLStreamException {
throw new IllegalStateException();
}
@Override
- public DataHandlerProvider getDataHandlerProvider() {
+ public BlobProvider getBlobProvider() {
throw new IllegalStateException();
}
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/common/factory/OMFactoryImpl.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/common/factory/OMFactoryImpl.java
index 6ab4be784..9add26edd 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/common/factory/OMFactoryImpl.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/common/factory/OMFactoryImpl.java
@@ -26,7 +26,7 @@ import javax.activation.DataHandler;
import javax.xml.namespace.QName;
import org.apache.axiom.core.CoreModelException;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.ext.stax.BlobProvider;
import org.apache.axiom.om.OMAttribute;
import org.apache.axiom.om.OMComment;
import org.apache.axiom.om.OMContainer;
@@ -64,6 +64,7 @@ import org.apache.axiom.om.impl.intf.AxiomText;
import org.apache.axiom.om.impl.intf.TextContent;
import org.apache.axiom.om.impl.intf.factory.AxiomElementType;
import org.apache.axiom.om.impl.intf.factory.AxiomNodeFactory;
+import org.apache.axiom.util.activation.DataHandlerUtils;
public class OMFactoryImpl implements OMFactory {
protected final AxiomNodeFactory nodeFactory;
@@ -213,14 +214,16 @@ public class OMFactoryImpl implements OMFactory {
@Override
public final OMText createOMText(DataHandler dataHandler, boolean
optimize) {
return createAxiomText(
- null, new TextContent(null, dataHandler, optimize),
OMNode.TEXT_NODE);
+ null,
+ new TextContent(null, DataHandlerUtils.toBlob(dataHandler),
optimize),
+ OMNode.TEXT_NODE);
}
@Override
public final OMText createOMText(
- String contentID, DataHandlerProvider dataHandlerProvider, boolean
optimize) {
+ String contentID, BlobProvider blobProvider, boolean optimize) {
return createAxiomText(
- null, new TextContent(contentID, dataHandlerProvider,
optimize), OMNode.TEXT_NODE);
+ null, new TextContent(contentID, blobProvider, optimize),
OMNode.TEXT_NODE);
}
@Override
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/intf/TextContent.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/intf/TextContent.java
index 71dad3b94..07c9542e4 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/intf/TextContent.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/intf/TextContent.java
@@ -20,18 +20,17 @@ package org.apache.axiom.om.impl.intf;
import java.io.IOException;
-import javax.activation.DataHandler;
-
+import org.apache.axiom.blob.Blob;
import org.apache.axiom.blob.Blobs;
import org.apache.axiom.core.ClonePolicy;
import org.apache.axiom.core.CloneableCharacterData;
import org.apache.axiom.core.stream.CharacterData;
import org.apache.axiom.core.stream.CharacterDataSink;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.ext.stax.BlobProvider;
import org.apache.axiom.om.OMCloneOptions;
import org.apache.axiom.om.OMException;
import org.apache.axiom.util.UIDGenerator;
-import org.apache.axiom.util.activation.BlobDataSource;
+import org.apache.axiom.util.activation.DataHandlerUtils;
import org.apache.axiom.util.base64.AbstractBase64EncodingOutputStream;
import org.apache.axiom.util.base64.Base64EncodingStringBufferOutputStream;
import org.apache.axiom.util.base64.Base64Utils;
@@ -45,10 +44,10 @@ public final class TextContent implements
CloneableCharacterData {
private String contentID;
/**
- * Contains a {@link DataHandler} or {@link DataHandlerProvider} object if
the text node
- * represents base64 encoded binary data.
+ * Contains a {@link Blob} or {@link BlobProvider} object if the text node
represents base64
+ * encoded binary data.
*/
- private Object dataHandlerObject;
+ private Object blobObject;
private boolean optimize;
private boolean binary;
@@ -65,11 +64,11 @@ public final class TextContent implements
CloneableCharacterData {
this.optimize = optimize;
}
- public TextContent(String contentID, Object dataHandlerObject, boolean
optimize) {
+ public TextContent(String contentID, Object blobObject, boolean optimize) {
this.value = null;
mimeType = null;
this.contentID = contentID;
- this.dataHandlerObject = dataHandlerObject;
+ this.blobObject = blobObject;
binary = true;
this.optimize = optimize;
}
@@ -78,7 +77,7 @@ public final class TextContent implements
CloneableCharacterData {
this.value = other.value;
this.mimeType = other.mimeType;
this.contentID = other.contentID;
- this.dataHandlerObject = other.dataHandlerObject;
+ this.blobObject = other.blobObject;
this.optimize = other.optimize;
this.binary = other.binary;
}
@@ -113,33 +112,33 @@ public final class TextContent implements
CloneableCharacterData {
this.contentID = contentID;
}
- public Object getDataHandlerObject() {
- return dataHandlerObject;
+ public Object getBlobObject() {
+ return blobObject;
}
- public DataHandler getDataHandler() {
- if (dataHandlerObject != null) {
- if (dataHandlerObject instanceof DataHandlerProvider) {
+ public Blob getBlob() {
+ if (blobObject != null) {
+ if (blobObject instanceof BlobProvider) {
try {
- dataHandlerObject = ((DataHandlerProvider)
dataHandlerObject).getDataHandler();
+ blobObject = ((BlobProvider) blobObject).getBlob();
} catch (IOException ex) {
throw new OMException(ex);
}
}
- return (DataHandler) dataHandlerObject;
+ return (Blob) blobObject;
} else if (binary) {
- return new DataHandler(
- new
BlobDataSource(Blobs.createBlob(Base64Utils.decode(value)), mimeType));
+ return Blobs.createBlob(Base64Utils.decode(value));
} else {
- throw new OMException("No DataHandler available");
+ throw new OMException("No Blob available");
}
}
@Override
public String toString() {
- if (dataHandlerObject != null) {
+ if (blobObject != null) {
try {
- return Base64Utils.encode(getDataHandler());
+ // TODO(AXIOM-506): avoid conversion here
+ return
Base64Utils.encode(DataHandlerUtils.toDataHandler(getBlob()));
} catch (Exception e) {
throw new OMException(e);
}
@@ -149,9 +148,10 @@ public final class TextContent implements
CloneableCharacterData {
}
public char[] toCharArray() {
- if (dataHandlerObject != null) {
+ if (blobObject != null) {
try {
- return Base64Utils.encodeToCharArray(getDataHandler());
+ // TODO(AXIOM-506): avoid conversion here
+ return
Base64Utils.encodeToCharArray(DataHandlerUtils.toDataHandler(getBlob()));
} catch (IOException ex) {
throw new OMException(ex);
}
@@ -167,7 +167,8 @@ public final class TextContent implements
CloneableCharacterData {
&& ((OMCloneOptions) options).isFetchDataHandlers()) {
// Force loading of the reference to the DataHandler and ensure
that its content is
// completely fetched into memory (or temporary storage).
- getDataHandler().getDataSource();
+ // TODO(AXIOM-506): review this
+ DataHandlerUtils.toDataHandler(getBlob()).getDataSource();
}
return new TextContent(this);
}
@@ -176,7 +177,7 @@ public final class TextContent implements
CloneableCharacterData {
public void writeTo(CharacterDataSink sink) throws IOException {
if (binary) {
AbstractBase64EncodingOutputStream out =
sink.getBase64EncodingOutputStream();
- getDataHandler().writeTo(out);
+ getBlob().writeTo(out);
out.complete();
} else {
// TODO: there must be a better way to just write a String
@@ -190,7 +191,7 @@ public final class TextContent implements
CloneableCharacterData {
Base64EncodingStringBufferOutputStream out =
new Base64EncodingStringBufferOutputStream(buffer);
try {
- getDataHandler().writeTo(out);
+ getBlob().writeTo(out);
out.complete();
} catch (IOException ex) {
throw new OMException(ex);
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/mixin/AxiomTextMixin.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/mixin/AxiomTextMixin.java
index f578b9ec3..e248b1c12 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/mixin/AxiomTextMixin.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/mixin/AxiomTextMixin.java
@@ -31,6 +31,7 @@ import org.apache.axiom.om.impl.common.AxiomSemantics;
import org.apache.axiom.om.impl.common.OMNamespaceImpl;
import org.apache.axiom.om.impl.intf.AxiomText;
import org.apache.axiom.om.impl.intf.TextContent;
+import org.apache.axiom.util.activation.DataHandlerUtils;
import org.apache.axiom.weaver.annotation.Mixin;
@Mixin
@@ -132,7 +133,7 @@ public abstract class AxiomTextMixin implements AxiomText {
try {
Object content = coreGetCharacterData();
if (content instanceof TextContent) {
- return ((TextContent) content).getDataHandler();
+ return DataHandlerUtils.toDataHandler(((TextContent)
content).getBlob());
} else {
throw new OMException("No DataHandler available");
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/ds/PushOMDataSourceXOPHandler.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/ds/PushOMDataSourceXOPHandler.java
index 8793985cf..980d249b8 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/ds/PushOMDataSourceXOPHandler.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/ds/PushOMDataSourceXOPHandler.java
@@ -29,6 +29,7 @@ import
org.apache.axiom.core.stream.xop.AbstractXOPDecodingFilterHandler;
import org.apache.axiom.om.impl.intf.TextContent;
import org.apache.axiom.om.impl.stream.xop.XOPHandler;
import org.apache.axiom.util.UIDGenerator;
+import org.apache.axiom.util.activation.DataHandlerUtils;
final class PushOMDataSourceXOPHandler extends AbstractXOPDecodingFilterHandler
implements XOPHandler {
@@ -51,6 +52,6 @@ final class PushOMDataSourceXOPHandler extends
AbstractXOPDecodingFilterHandler
if (dataHandler == null) {
throw new StreamException("No DataHandler found for content ID " +
contentID);
}
- return new TextContent(contentID, dataHandler, true);
+ return new TextContent(contentID,
DataHandlerUtils.toBlob(dataHandler), true);
}
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/AxiomXMLStreamReaderExtensionFactory.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/AxiomXMLStreamReaderExtensionFactory.java
index 911a312e4..8c0e46888 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/AxiomXMLStreamReaderExtensionFactory.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/AxiomXMLStreamReaderExtensionFactory.java
@@ -20,9 +20,9 @@ package org.apache.axiom.om.impl.stream.stax.pull;
import org.apache.axiom.core.stream.stax.pull.output.InternalXMLStreamReader;
import
org.apache.axiom.core.stream.stax.pull.output.XMLStreamReaderExtensionFactory;
+import org.apache.axiom.ext.stax.BlobReader;
import org.apache.axiom.ext.stax.CharacterDataReader;
import org.apache.axiom.ext.stax.DTDReader;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerReader;
public final class AxiomXMLStreamReaderExtensionFactory implements
XMLStreamReaderExtensionFactory {
public static final AxiomXMLStreamReaderExtensionFactory INSTANCE =
@@ -32,8 +32,8 @@ public final class AxiomXMLStreamReaderExtensionFactory
implements XMLStreamRead
@Override
public Object createExtension(String propertyName, InternalXMLStreamReader
reader) {
- if (propertyName.equals(DataHandlerReader.PROPERTY)) {
- return new DataHandlerReaderImpl(reader);
+ if (propertyName.equals(BlobReader.PROPERTY)) {
+ return new BlobReaderImpl(reader);
} else if (propertyName.equals(DTDReader.PROPERTY)) {
return new DTDReaderImpl(reader);
} else if (propertyName.equals(CharacterDataReader.PROPERTY)) {
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/AxiomXMLStreamReaderHelper.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/AxiomXMLStreamReaderHelper.java
index 8fe733d97..be84bec2e 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/AxiomXMLStreamReaderHelper.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/AxiomXMLStreamReaderHelper.java
@@ -25,8 +25,8 @@ import org.apache.axiom.core.stream.CharacterData;
import org.apache.axiom.core.stream.StreamException;
import org.apache.axiom.core.stream.stax.pull.input.DTDInfo;
import org.apache.axiom.core.stream.stax.pull.input.XMLStreamReaderHelper;
+import org.apache.axiom.ext.stax.BlobReader;
import org.apache.axiom.ext.stax.DTDReader;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerReader;
import org.apache.axiom.om.impl.intf.TextContent;
import org.apache.axiom.util.stax.XMLStreamReaderUtils;
@@ -34,14 +34,14 @@ final class AxiomXMLStreamReaderHelper extends
XMLStreamReaderHelper {
private final XMLStreamReader reader;
/**
- * Reference to the {@link DataHandlerReader} extension of the reader, or
<code>null</code> if
- * the reader doesn't support this extension.
+ * Reference to the {@link BlobReader} extension of the reader, or
<code>null</code> if the
+ * reader doesn't support this extension.
*/
- private final DataHandlerReader dataHandlerReader;
+ private final BlobReader blobReader;
AxiomXMLStreamReaderHelper(XMLStreamReader reader) {
this.reader = reader;
- dataHandlerReader = XMLStreamReaderUtils.getDataHandlerReader(reader);
+ blobReader = XMLStreamReaderUtils.getBlobReader(reader);
}
@Override
@@ -62,18 +62,18 @@ final class AxiomXMLStreamReaderHelper extends
XMLStreamReaderHelper {
@Override
public CharacterData getCharacterData() throws StreamException {
- if (dataHandlerReader != null && dataHandlerReader.isBinary()) {
- if (dataHandlerReader.isDeferred()) {
+ if (blobReader != null && blobReader.isBinary()) {
+ if (blobReader.isDeferred()) {
return new TextContent(
- dataHandlerReader.getContentID(),
- dataHandlerReader.getDataHandlerProvider(),
- dataHandlerReader.isOptimized());
+ blobReader.getContentID(),
+ blobReader.getBlobProvider(),
+ blobReader.isOptimized());
} else {
try {
return new TextContent(
- dataHandlerReader.getContentID(),
- dataHandlerReader.getDataHandler(),
- dataHandlerReader.isOptimized());
+ blobReader.getContentID(),
+ blobReader.getBlob(),
+ blobReader.isOptimized());
} catch (XMLStreamException ex) {
throw new StreamException(ex);
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/DataHandlerReaderImpl.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/BlobReaderImpl.java
similarity index 71%
rename from
mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/DataHandlerReaderImpl.java
rename to
mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/BlobReaderImpl.java
index 8a4a0e2a7..a4c0735b9 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/DataHandlerReaderImpl.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/pull/BlobReaderImpl.java
@@ -18,19 +18,19 @@
*/
package org.apache.axiom.om.impl.stream.stax.pull;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
+import org.apache.axiom.blob.Blob;
import org.apache.axiom.core.stream.stax.pull.output.InternalXMLStreamReader;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerReader;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobReader;
import org.apache.axiom.om.impl.intf.TextContent;
-final class DataHandlerReaderImpl implements DataHandlerReader {
+final class BlobReaderImpl implements BlobReader {
private final InternalXMLStreamReader reader;
- DataHandlerReaderImpl(InternalXMLStreamReader reader) {
+ BlobReaderImpl(InternalXMLStreamReader reader) {
this.reader = reader;
}
@@ -51,8 +51,7 @@ final class DataHandlerReaderImpl implements
DataHandlerReader {
@Override
public boolean isDeferred() {
- return ((TextContent) reader.getCharacterData()).getDataHandlerObject()
- instanceof DataHandlerProvider;
+ return ((TextContent) reader.getCharacterData()).getBlobObject()
instanceof BlobProvider;
}
@Override
@@ -61,13 +60,12 @@ final class DataHandlerReaderImpl implements
DataHandlerReader {
}
@Override
- public DataHandler getDataHandler() throws XMLStreamException {
- return ((TextContent) reader.getCharacterData()).getDataHandler();
+ public Blob getBlob() throws XMLStreamException {
+ return ((TextContent) reader.getCharacterData()).getBlob();
}
@Override
- public DataHandlerProvider getDataHandlerProvider() {
- return (DataHandlerProvider)
- ((TextContent)
reader.getCharacterData()).getDataHandlerObject();
+ public BlobProvider getBlobProvider() {
+ return (BlobProvider) ((TextContent)
reader.getCharacterData()).getBlobObject();
}
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/AxiomXMLStreamWriterExtensionFactory.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/AxiomXMLStreamWriterExtensionFactory.java
index 1844504bc..33a14419e 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/AxiomXMLStreamWriterExtensionFactory.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/AxiomXMLStreamWriterExtensionFactory.java
@@ -20,7 +20,7 @@ package org.apache.axiom.om.impl.stream.stax.push;
import org.apache.axiom.core.stream.stax.push.input.InternalXMLStreamWriter;
import
org.apache.axiom.core.stream.stax.push.input.XMLStreamWriterExtensionFactory;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.ext.stax.BlobWriter;
public final class AxiomXMLStreamWriterExtensionFactory implements
XMLStreamWriterExtensionFactory {
public static final AxiomXMLStreamWriterExtensionFactory INSTANCE =
@@ -30,8 +30,8 @@ public final class AxiomXMLStreamWriterExtensionFactory
implements XMLStreamWrit
@Override
public Object createExtension(String propertyName, InternalXMLStreamWriter
writer) {
- if (DataHandlerWriter.PROPERTY.equals(propertyName)) {
- return new DataHandlerWriterImpl(writer);
+ if (BlobWriter.PROPERTY.equals(propertyName)) {
+ return new BlobWriterImpl(writer);
} else {
return null;
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/DataHandlerWriterImpl.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/BlobWriterImpl.java
similarity index 66%
rename from
mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/DataHandlerWriterImpl.java
rename to
mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/BlobWriterImpl.java
index de13cf8d8..3bf5c8557 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/DataHandlerWriterImpl.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/BlobWriterImpl.java
@@ -20,31 +20,30 @@ package org.apache.axiom.om.impl.stream.stax.push;
import java.io.IOException;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
+import org.apache.axiom.blob.Blob;
import org.apache.axiom.core.stream.stax.push.input.InternalXMLStreamWriter;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobWriter;
import org.apache.axiom.om.impl.intf.TextContent;
-public final class DataHandlerWriterImpl implements DataHandlerWriter {
+public final class BlobWriterImpl implements BlobWriter {
private final InternalXMLStreamWriter writer;
- public DataHandlerWriterImpl(InternalXMLStreamWriter writer) {
+ public BlobWriterImpl(InternalXMLStreamWriter writer) {
this.writer = writer;
}
@Override
- public void writeDataHandler(DataHandler dataHandler, String contentID,
boolean optimize)
+ public void writeBlob(Blob blob, String contentID, boolean optimize)
throws IOException, XMLStreamException {
- writer.writeCharacterData(new TextContent(contentID, dataHandler,
optimize));
+ writer.writeCharacterData(new TextContent(contentID, blob, optimize));
}
@Override
- public void writeDataHandler(
- DataHandlerProvider dataHandlerProvider, String contentID, boolean
optimize)
+ public void writeBlob(BlobProvider blobProvider, String contentID, boolean
optimize)
throws IOException, XMLStreamException {
- writer.writeCharacterData(new TextContent(contentID,
dataHandlerProvider, optimize));
+ writer.writeCharacterData(new TextContent(contentID, blobProvider,
optimize));
}
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/XMLStreamWriterHandler.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/XMLStreamWriterHandler.java
index 16a21d625..d0075de67 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/XMLStreamWriterHandler.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/stax/push/XMLStreamWriterHandler.java
@@ -25,8 +25,8 @@ import org.apache.axiom.core.stream.StreamException;
import org.apache.axiom.core.stream.XmlHandler;
import org.apache.axiom.core.stream.serializer.Serializer;
import org.apache.axiom.core.stream.util.CharacterDataAccumulator;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobWriter;
import org.apache.axiom.om.impl.intf.TextContent;
import org.apache.axiom.util.stax.XMLStreamWriterUtils;
@@ -35,7 +35,7 @@ import javax.xml.stream.XMLStreamWriter;
public class XMLStreamWriterHandler implements XmlHandler {
private final XMLStreamWriter writer;
- private DataHandlerWriter dataHandlerWriter;
+ private BlobWriter blobWriter;
private final CharacterDataAccumulator buffer = new
CharacterDataAccumulator();
private boolean buffering;
private String piTarget;
@@ -163,17 +163,17 @@ public class XMLStreamWriterHandler implements XmlHandler
{
if (data instanceof TextContent) {
TextContent textContent = (TextContent) data;
if (textContent.isBinary()) {
- Object dataHandlerObject =
textContent.getDataHandlerObject();
- if (dataHandlerObject instanceof DataHandlerProvider) {
- getDataHandlerWriter()
- .writeDataHandler(
- (DataHandlerProvider)
dataHandlerObject,
+ Object blobObject = textContent.getBlobObject();
+ if (blobObject instanceof BlobProvider) {
+ getBlobWriter()
+ .writeBlob(
+ (BlobProvider) blobObject,
textContent.getContentID(),
textContent.isOptimize());
} else {
- getDataHandlerWriter()
- .writeDataHandler(
- textContent.getDataHandler(),
+ getBlobWriter()
+ .writeBlob(
+ textContent.getBlob(),
textContent.getContentID(),
textContent.isOptimize());
}
@@ -241,12 +241,12 @@ public class XMLStreamWriterHandler implements XmlHandler
{
}
}
- private DataHandlerWriter getDataHandlerWriter() {
- // We only retrieve/create the DataHandlerWriter if necessary
- if (dataHandlerWriter == null) {
- dataHandlerWriter =
XMLStreamWriterUtils.getDataHandlerWriter(writer);
+ private BlobWriter getBlobWriter() {
+ // We only retrieve/create the BlobWriter if necessary
+ if (blobWriter == null) {
+ blobWriter = XMLStreamWriterUtils.getBlobWriter(writer);
}
- return dataHandlerWriter;
+ return blobWriter;
}
@Override
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/ContentIDGenerator.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/ContentIDGenerator.java
index e97c0ca22..cfc3d440f 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/ContentIDGenerator.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/ContentIDGenerator.java
@@ -44,7 +44,7 @@ public interface ContentIDGenerator {
*
* @param existingContentID An existing content ID for the {@link
javax.activation.DataHandler}
* being processed, as returned by {@link
- *
org.apache.axiom.ext.stax.datahandler.DataHandlerReader#getContentID()}, or
<code>null
+ * org.apache.axiom.ext.stax.BlobReader#getContentID()}, or <code>null
* </code> if no existing content ID is known. The implementation is
free to use this
* information or not.
* @return the content ID; may not be <code>null</code>
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/OptimizationPolicy.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/OptimizationPolicy.java
index 9172c964f..0b6778a8a 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/OptimizationPolicy.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/OptimizationPolicy.java
@@ -23,18 +23,16 @@ import java.io.IOException;
import javax.activation.DataHandler;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.ext.stax.BlobProvider;
/**
* Encapsulates an algorithm that decides whether base64 encoded binary data
should be optimized
* using XOP. The implementation takes the decision based on the submitted
binary content and the
* "eligible for optimization" flag. Depending on the context of use, this
flag is provided by the
- * return value of {@link
org.apache.axiom.ext.stax.datahandler.DataHandlerReader#isOptimized()} or
- * the <code>optimize</code> argument of {@link
- *
org.apache.axiom.ext.stax.datahandler.DataHandlerWriter#writeDataHandler(DataHandler,
String,
- * boolean)} or {@link
- *
org.apache.axiom.ext.stax.datahandler.DataHandlerWriter#writeDataHandler(DataHandlerProvider,
- * String, boolean)}.
+ * return value of {@link org.apache.axiom.ext.stax.BlobReader#isOptimized()}
or the <code>optimize
+ * </code> argument of {@link
org.apache.axiom.ext.stax.BlobWriter#writeBlob(DataHandler, String,
+ * boolean)} or {@link
org.apache.axiom.ext.stax.BlobWriter#writeBlob(BlobProvider, String,
+ * boolean)}.
*/
public interface OptimizationPolicy {
/**
@@ -48,8 +46,7 @@ public interface OptimizationPolicy {
}
@Override
- public boolean isOptimized(
- DataHandlerProvider dataHandlerProvider, boolean
optimize) {
+ public boolean isOptimized(BlobProvider dataHandlerProvider,
boolean optimize) {
return optimize;
}
};
@@ -66,8 +63,7 @@ public interface OptimizationPolicy {
}
@Override
- public boolean isOptimized(
- DataHandlerProvider dataHandlerProvider, boolean
optimize) {
+ public boolean isOptimized(BlobProvider dataHandlerProvider,
boolean optimize) {
return true;
}
};
@@ -86,16 +82,15 @@ public interface OptimizationPolicy {
boolean isOptimized(DataHandler dataHandler, boolean optimize) throws
IOException;
/**
- * Determine whether the binary content supplied by a given {@link
DataHandlerProvider} should
- * be optimized.
+ * Determine whether the binary content supplied by a given {@link
BlobProvider} should be
+ * optimized.
*
- * @param dataHandlerProvider the binary content
+ * @param blobProvider the binary content
* @param optimize indicates whether the binary content was initially
marked as eligible for
* optimization (see above)
* @return <code>true</code> if the binary content should be optimized
using XOP, i.e. encoded
* using {@code xop:Include}
* @throws IOException if an error occurs while reading the data handler
*/
- boolean isOptimized(DataHandlerProvider dataHandlerProvider, boolean
optimize)
- throws IOException;
+ boolean isOptimized(BlobProvider blobProvider, boolean optimize) throws
IOException;
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/OptimizationPolicyImpl.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/OptimizationPolicyImpl.java
index d709c7b6c..e2e79f01f 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/OptimizationPolicyImpl.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/OptimizationPolicyImpl.java
@@ -23,7 +23,7 @@ import java.io.IOException;
import javax.activation.DataHandler;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.ext.stax.BlobProvider;
import org.apache.axiom.om.OMOutputFormat;
import org.apache.axiom.util.activation.DataHandlerUtils;
import org.apache.commons.logging.Log;
@@ -62,8 +62,7 @@ public final class OptimizationPolicyImpl implements
OptimizationPolicy {
}
@Override
- public boolean isOptimized(DataHandlerProvider dataHandlerProvider,
boolean optimize)
- throws IOException {
+ public boolean isOptimized(BlobProvider blobProvider, boolean optimize)
throws IOException {
if (!optimize) {
return false;
@@ -72,7 +71,7 @@ public final class OptimizationPolicyImpl implements
OptimizationPolicy {
// DataHandlerProvider#getDataHandler(), which would force loading
the data handler.
return true;
} else {
- return isOptimized(dataHandlerProvider.getDataHandler(), optimize);
+ return
isOptimized(DataHandlerUtils.toDataHandler(blobProvider.getBlob()), optimize);
}
}
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/XOPDecodingFilterHandler.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/XOPDecodingFilterHandler.java
index 538226007..a9445cf27 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/XOPDecodingFilterHandler.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/XOPDecodingFilterHandler.java
@@ -22,15 +22,17 @@ import java.io.IOException;
import javax.activation.DataHandler;
+import org.apache.axiom.blob.Blob;
import org.apache.axiom.core.stream.XmlHandler;
import org.apache.axiom.core.stream.xop.AbstractXOPDecodingFilterHandler;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.ext.stax.BlobProvider;
import org.apache.axiom.om.OMAttachmentAccessor;
import org.apache.axiom.om.OMException;
import org.apache.axiom.om.impl.intf.TextContent;
+import org.apache.axiom.util.activation.DataHandlerUtils;
final class XOPDecodingFilterHandler extends AbstractXOPDecodingFilterHandler {
- private static class DataHandlerProviderImpl implements
DataHandlerProvider {
+ private static class DataHandlerProviderImpl implements BlobProvider {
private final OMAttachmentAccessor attachmentAccessor;
private final String contentID;
@@ -40,12 +42,12 @@ final class XOPDecodingFilterHandler extends
AbstractXOPDecodingFilterHandler {
}
@Override
- public DataHandler getDataHandler() throws IOException {
+ public Blob getBlob() throws IOException {
DataHandler dh = attachmentAccessor.getDataHandler(contentID);
if (dh == null) {
throw new OMException("No MIME part found for content ID '" +
contentID + "'");
} else {
- return dh;
+ return DataHandlerUtils.toBlob(dh);
}
}
}
diff --git
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/XOPEncodingFilterHandler.java
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/XOPEncodingFilterHandler.java
index 742ee4390..3e1f98d86 100644
---
a/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/XOPEncodingFilterHandler.java
+++
b/mixins/om-mixins/src/main/java/org/apache/axiom/om/impl/stream/xop/XOPEncodingFilterHandler.java
@@ -26,17 +26,19 @@ import java.util.Set;
import javax.activation.DataHandler;
+import org.apache.axiom.blob.Blob;
import org.apache.axiom.core.stream.StreamException;
import org.apache.axiom.core.stream.XmlHandler;
import org.apache.axiom.core.stream.xop.AbstractXOPEncodingFilterHandler;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.ext.stax.BlobProvider;
import org.apache.axiom.om.OMAttachmentAccessor;
import org.apache.axiom.om.OMException;
import org.apache.axiom.om.impl.intf.TextContent;
+import org.apache.axiom.util.activation.DataHandlerUtils;
public final class XOPEncodingFilterHandler extends
AbstractXOPEncodingFilterHandler
implements XOPHandler, OMAttachmentAccessor {
- private final Map<String, Object> dataHandlerObjects = new
LinkedHashMap<String, Object>();
+ private final Map<String, Object> blobObjects = new LinkedHashMap<String,
Object>();
private final ContentIDGenerator contentIDGenerator;
private final OptimizationPolicy optimizationPolicy;
@@ -59,7 +61,7 @@ public final class XOPEncodingFilterHandler extends
AbstractXOPEncodingFilterHan
}
if (doOptimize) {
String contentID = contentIDGenerator.generateContentID(null);
- dataHandlerObjects.put(contentID, dataHandler);
+ blobObjects.put(contentID, DataHandlerUtils.toBlob(dataHandler));
return contentID;
} else {
return null;
@@ -75,19 +77,19 @@ public final class XOPEncodingFilterHandler extends
AbstractXOPEncodingFilterHan
* returned.
*/
public Set<String> getContentIDs() {
- return Collections.unmodifiableSet(dataHandlerObjects.keySet());
+ return Collections.unmodifiableSet(blobObjects.keySet());
}
@Override
public DataHandler getDataHandler(String contentID) {
- Object dataHandlerObject = dataHandlerObjects.get(contentID);
- if (dataHandlerObject == null) {
+ Object blobObject = blobObjects.get(contentID);
+ if (blobObject == null) {
return null;
- } else if (dataHandlerObject instanceof DataHandler) {
- return (DataHandler) dataHandlerObject;
+ } else if (blobObject instanceof Blob) {
+ return DataHandlerUtils.toDataHandler((Blob) blobObject);
} else {
try {
- return ((DataHandlerProvider)
dataHandlerObject).getDataHandler();
+ return DataHandlerUtils.toDataHandler(((BlobProvider)
blobObject).getBlob());
} catch (IOException ex) {
throw new OMException(ex);
}
@@ -99,18 +101,18 @@ public final class XOPEncodingFilterHandler extends
AbstractXOPEncodingFilterHan
if (data instanceof TextContent) {
TextContent textContent = (TextContent) data;
if (textContent.isBinary()) {
- Object dataHandlerObject = textContent.getDataHandlerObject();
+ Object blobObject = textContent.getBlobObject();
boolean optimize;
try {
- if (dataHandlerObject instanceof DataHandlerProvider) {
+ if (blobObject instanceof BlobProvider) {
optimize =
optimizationPolicy.isOptimized(
- (DataHandlerProvider)
dataHandlerObject,
- textContent.isOptimize());
+ (BlobProvider) blobObject,
textContent.isOptimize());
} else {
optimize =
optimizationPolicy.isOptimized(
- (DataHandler) dataHandlerObject,
textContent.isOptimize());
+ DataHandlerUtils.toDataHandler((Blob)
blobObject),
+ textContent.isOptimize());
}
} catch (IOException ex) {
throw new StreamException(ex);
@@ -118,7 +120,7 @@ public final class XOPEncodingFilterHandler extends
AbstractXOPEncodingFilterHan
if (optimize) {
String contentID =
contentIDGenerator.generateContentID(textContent.getContentID());
- dataHandlerObjects.put(contentID, dataHandlerObject);
+ blobObjects.put(contentID, blobObject);
return contentID;
}
}
diff --git a/samples/src/test/java/org/apache/axiom/samples/LogWriter.java
b/samples/src/test/java/org/apache/axiom/samples/LogWriter.java
index 410c36db6..4a17e17c1 100644
--- a/samples/src/test/java/org/apache/axiom/samples/LogWriter.java
+++ b/samples/src/test/java/org/apache/axiom/samples/LogWriter.java
@@ -20,23 +20,23 @@ package org.apache.axiom.samples;
import java.io.IOException;
-import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.blob.Blob;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobWriter;
import org.apache.axiom.util.stax.wrapper.XMLStreamWriterWrapper;
// START SNIPPET: main
-public class LogWriter extends XMLStreamWriterWrapper implements
DataHandlerWriter {
+public class LogWriter extends XMLStreamWriterWrapper implements BlobWriter {
public LogWriter(XMLStreamWriter parent) {
super(parent);
}
@Override
public Object getProperty(String name) throws IllegalArgumentException {
- if (name.equals(DataHandlerWriter.PROPERTY)) {
+ if (name.equals(BlobWriter.PROPERTY)) {
return this;
} else {
return super.getProperty(name);
@@ -44,13 +44,13 @@ public class LogWriter extends XMLStreamWriterWrapper
implements DataHandlerWrit
}
@Override
- public void writeDataHandler(DataHandler dataHandler, String contentID,
boolean optimize)
+ public void writeBlob(Blob blob, String contentID, boolean optimize)
throws IOException, XMLStreamException {
super.writeCharacters("[base64 encoded data]");
}
@Override
- public void writeDataHandler(DataHandlerProvider dataHandlerProvider,
String contentID,
+ public void writeBlob(BlobProvider blobProvider, String contentID,
boolean optimize) throws IOException, XMLStreamException {
super.writeCharacters("[base64 encoded data]");
}
diff --git
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/OMTestSuiteBuilder.java
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/OMTestSuiteBuilder.java
index 8b1b0e61d..147a7af61 100644
---
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/OMTestSuiteBuilder.java
+++
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/OMTestSuiteBuilder.java
@@ -876,12 +876,8 @@ public class OMTestSuiteBuilder extends
MatrixTestSuiteBuilder {
addTest(new
org.apache.axiom.ts.om.element.sr.TestCommentEvent(metaFactory, bf, true));
addTest(new
org.apache.axiom.ts.om.element.sr.TestCommentEvent(metaFactory, bf, false));
}
- addTest(
- new
org.apache.axiom.ts.om.element.sr.TestGetDataHandlerFromElement(
- metaFactory, true));
- addTest(
- new
org.apache.axiom.ts.om.element.sr.TestGetDataHandlerFromElement(
- metaFactory, false));
+ addTest(new
org.apache.axiom.ts.om.element.sr.TestGetBlobFromElement(metaFactory, true));
+ addTest(new
org.apache.axiom.ts.om.element.sr.TestGetBlobFromElement(metaFactory, false));
addTest(new
org.apache.axiom.ts.om.element.sr.TestGetElementText(metaFactory));
for (BuilderFactory bf : getInstances(BuilderFactory.class)) {
addTest(
@@ -989,10 +985,10 @@ public class OMTestSuiteBuilder extends
MatrixTestSuiteBuilder {
metaFactory));
addTest(new
org.apache.axiom.ts.om.factory.TestCreateOMText(metaFactory));
addTest(
- new
org.apache.axiom.ts.om.factory.TestCreateOMTextFromDataHandlerProvider(
+ new
org.apache.axiom.ts.om.factory.TestCreateOMTextFromBlobProvider(
metaFactory, false));
addTest(
- new
org.apache.axiom.ts.om.factory.TestCreateOMTextFromDataHandlerProvider(
+ new
org.apache.axiom.ts.om.factory.TestCreateOMTextFromBlobProvider(
metaFactory, true));
addTest(new
org.apache.axiom.ts.om.factory.TestCreateOMTextFromOMText(metaFactory));
addTest(new
org.apache.axiom.ts.om.factory.TestCreateOMTextWithNullParent(metaFactory));
diff --git
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/element/sr/TestGetDataHandlerFromElement.java
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/element/sr/TestGetBlobFromElement.java
similarity index 83%
rename from
testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/element/sr/TestGetDataHandlerFromElement.java
rename to
testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/element/sr/TestGetBlobFromElement.java
index 667f32da7..67e9bf048 100644
---
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/element/sr/TestGetDataHandlerFromElement.java
+++
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/element/sr/TestGetBlobFromElement.java
@@ -21,10 +21,10 @@ package org.apache.axiom.ts.om.element.sr;
import java.io.StringReader;
import javax.activation.DataHandler;
-import javax.activation.DataSource;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamReader;
+import org.apache.axiom.blob.Blob;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.OMMetaFactory;
@@ -35,13 +35,13 @@ import org.apache.axiom.ts.AxiomTestCase;
import org.apache.axiom.util.stax.XMLStreamReaderUtils;
/**
- * Tests {@link
XMLStreamReaderUtils#getDataHandlerFromElement(XMLStreamReader)} on an {@link
+ * Tests {@link XMLStreamReaderUtils#getBlobFromElement(XMLStreamReader)} on
an {@link
* XMLStreamReader} returned by {@link OMElement#getXMLStreamReader(boolean)}.
*/
-public class TestGetDataHandlerFromElement extends AxiomTestCase {
+public class TestGetBlobFromElement extends AxiomTestCase {
private final boolean cache;
- public TestGetDataHandlerFromElement(OMMetaFactory metaFactory, boolean
cache) {
+ public TestGetBlobFromElement(OMMetaFactory metaFactory, boolean cache) {
super(metaFactory);
this.cache = cache;
addTestParameter("cache", cache);
@@ -60,7 +60,7 @@ public class TestGetDataHandlerFromElement extends
AxiomTestCase {
XMLStreamReader reader = root.getXMLStreamReader(cache);
assertEquals(XMLStreamReader.START_ELEMENT, reader.next());
assertEquals(XMLStreamReader.START_ELEMENT, reader.next());
- DataSource ds =
XMLStreamReaderUtils.getDataHandlerFromElement(reader).getDataSource();
- IOTestUtils.compareStreams(orgDS.getInputStream(),
ds.getInputStream());
+ Blob blob = XMLStreamReaderUtils.getBlobFromElement(reader);
+ IOTestUtils.compareStreams(orgDS.getInputStream(),
blob.getInputStream());
}
}
diff --git
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/factory/TestCreateOMTextFromDataHandlerProvider.java
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/factory/TestCreateOMTextFromBlobProvider.java
similarity index 72%
rename from
testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/factory/TestCreateOMTextFromDataHandlerProvider.java
rename to
testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/factory/TestCreateOMTextFromBlobProvider.java
index bf9f23e3a..a38ddbb62 100644
---
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/factory/TestCreateOMTextFromDataHandlerProvider.java
+++
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/factory/TestCreateOMTextFromBlobProvider.java
@@ -22,34 +22,35 @@ import static com.google.common.truth.Truth.assertThat;
import javax.activation.DataHandler;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
+import org.apache.axiom.blob.Blob;
+import org.apache.axiom.ext.stax.BlobProvider;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.OMMetaFactory;
import org.apache.axiom.om.OMText;
import org.apache.axiom.ts.AxiomTestCase;
import org.apache.axiom.util.UIDGenerator;
+import org.apache.axiom.util.activation.DataHandlerUtils;
-public class TestCreateOMTextFromDataHandlerProvider extends AxiomTestCase {
- static class TestDataHandlerProvider implements DataHandlerProvider {
- private DataHandler dh;
+public class TestCreateOMTextFromBlobProvider extends AxiomTestCase {
+ static class TestDataHandlerProvider implements BlobProvider {
+ private Blob blob;
@Override
- public DataHandler getDataHandler() {
- if (dh == null) {
- dh = new DataHandler("Data", "text/plain");
+ public Blob getBlob() {
+ if (blob == null) {
+ blob = DataHandlerUtils.toBlob(new DataHandler("Data",
"text/plain"));
}
- return dh;
+ return blob;
}
- public boolean isDataHandlerCreated() {
- return dh != null;
+ public boolean isBlobCreated() {
+ return blob != null;
}
}
private final boolean nullContentID;
- public TestCreateOMTextFromDataHandlerProvider(
- OMMetaFactory metaFactory, boolean nullContentID) {
+ public TestCreateOMTextFromBlobProvider(OMMetaFactory metaFactory, boolean
nullContentID) {
super(metaFactory);
this.nullContentID = nullContentID;
addTestParameter("nullContentId", nullContentID);
@@ -61,9 +62,9 @@ public class TestCreateOMTextFromDataHandlerProvider extends
AxiomTestCase {
OMFactory factory = metaFactory.getOMFactory();
String contentID = nullContentID ? null :
UIDGenerator.generateContentId();
OMText text = factory.createOMText(contentID, prov, true);
- assertFalse(prov.isDataHandlerCreated());
+ assertFalse(prov.isBlobCreated());
assertEquals(text.getDataHandler().getContent(), "Data");
- assertTrue(prov.isDataHandlerCreated());
+ assertTrue(prov.isBlobCreated());
if (contentID == null) {
assertThat(text.getContentID()).isNotNull();
} else {
diff --git
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/PushOMDataSourceScenario.java
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/PushOMDataSourceScenario.java
index 3082bf035..111ad7470 100644
---
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/PushOMDataSourceScenario.java
+++
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/PushOMDataSourceScenario.java
@@ -42,8 +42,8 @@ public interface PushOMDataSourceScenario extends Dimension {
new WriteCDataScenario(),
new WriteCharactersCharArrayScenario(),
new WriteCommentScenario(),
- new WriteDataHandlerScenario(),
- new WriteDataHandlerProviderScenario(),
+ new WriteBlobScenario(),
+ new WriteBlobProviderScenario(),
new WriteEmptyElementScenario(),
new WriteEmptyElementAutoPrefixScenario(),
new WriteEmptyElementNamespaceUnawareScenario(),
diff --git
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteDataHandlerProviderScenario.java
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteBlobProviderScenario.java
similarity index 79%
rename from
testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteDataHandlerProviderScenario.java
rename to
testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteBlobProviderScenario.java
index 579d43406..170adb229 100644
---
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteDataHandlerProviderScenario.java
+++
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteBlobProviderScenario.java
@@ -26,27 +26,29 @@ import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerProvider;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.blob.Blob;
+import org.apache.axiom.ext.stax.BlobProvider;
+import org.apache.axiom.ext.stax.BlobWriter;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMText;
import org.apache.axiom.testutils.activation.RandomDataSource;
import org.apache.axiom.testutils.io.IOTestUtils;
import org.apache.axiom.testutils.suite.MatrixTestCase;
+import org.apache.axiom.util.activation.DataHandlerUtils;
import org.apache.axiom.util.stax.XMLStreamWriterUtils;
import org.junit.Assert;
/**
- * Tests that {@link DataHandlerWriter#writeDataHandler(DataHandlerProvider,
String, boolean)}
- * creates an {@link OMText} backed by a {@link DataHandlerProvider}.
+ * Tests that {@link BlobWriter#writeBlob(BlobProvider, String, boolean)}
creates an {@link OMText}
+ * backed by a {@link BlobProvider}.
*/
-public class WriteDataHandlerProviderScenario implements
PushOMDataSourceScenario {
+public class WriteBlobProviderScenario implements PushOMDataSourceScenario {
private final DataHandler dh = new DataHandler(new RandomDataSource(1024));
- private final DataHandlerProvider dhp =
- new DataHandlerProvider() {
+ private final BlobProvider blobProvider =
+ new BlobProvider() {
@Override
- public DataHandler getDataHandler() throws IOException {
- return dh;
+ public Blob getBlob() throws IOException {
+ return DataHandlerUtils.toBlob(dh);
}
};
@@ -64,7 +66,7 @@ public class WriteDataHandlerProviderScenario implements
PushOMDataSourceScenari
public void serialize(XMLStreamWriter writer) throws XMLStreamException {
writer.writeStartElement(null, "root", null);
try {
- XMLStreamWriterUtils.writeDataHandler(writer, dhp, null, true);
+ XMLStreamWriterUtils.writeBlob(writer, blobProvider, null, true);
} catch (IOException ex) {
throw new XMLStreamException(ex);
}
diff --git
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteDataHandlerScenario.java
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteBlobScenario.java
similarity index 87%
rename from
testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteDataHandlerScenario.java
rename to
testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteBlobScenario.java
index c51167be2..978b3aab2 100644
---
a/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteDataHandlerScenario.java
+++
b/testing/axiom-testsuite/src/main/java/org/apache/axiom/ts/om/sourcedelement/push/WriteBlobScenario.java
@@ -26,20 +26,21 @@ import javax.activation.DataHandler;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import org.apache.axiom.ext.stax.datahandler.DataHandlerWriter;
+import org.apache.axiom.ext.stax.BlobWriter;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMText;
import org.apache.axiom.testutils.activation.RandomDataSource;
import org.apache.axiom.testutils.io.IOTestUtils;
import org.apache.axiom.testutils.suite.MatrixTestCase;
+import org.apache.axiom.util.activation.DataHandlerUtils;
import org.apache.axiom.util.stax.XMLStreamWriterUtils;
import org.junit.Assert;
/**
- * Tests that {@link DataHandlerWriter#writeDataHandler(DataHandler, String,
boolean)} creates an
- * {@link OMText} backed by a {@link DataHandler}.
+ * Tests that {@link BlobWriter#writeBlob(Blob, String, boolean)} creates an
{@link OMText} backed
+ * by a {@link Blob}.
*/
-public class WriteDataHandlerScenario implements PushOMDataSourceScenario {
+public class WriteBlobScenario implements PushOMDataSourceScenario {
private final DataHandler dh = new DataHandler(new RandomDataSource(1024));
@Override
@@ -56,7 +57,7 @@ public class WriteDataHandlerScenario implements
PushOMDataSourceScenario {
public void serialize(XMLStreamWriter writer) throws XMLStreamException {
writer.writeStartElement(null, "root", null);
try {
- XMLStreamWriterUtils.writeDataHandler(writer, dh, null, true);
+ XMLStreamWriterUtils.writeBlob(writer,
DataHandlerUtils.toBlob(dh), null, true);
} catch (IOException ex) {
throw new XMLStreamException(ex);
}
