diff -Nru libstax2-api-java-3.1.1/debian/build.xml libstax2-api-java-4.1/debian/build.xml
--- libstax2-api-java-3.1.1/debian/build.xml 2011-08-20 11:21:41.000000000 +0000
+++ libstax2-api-java-4.1/debian/build.xml 1970-01-01 00:00:00.000000000 +0000
@@ -1,528 +0,0 @@
-
-
- * Note: instances of AttributeInfo are only guaranteed to persist as long
- * as the (stream) reader points to the START_ELEMENT event, during
- * which attribute information was parsed. It is possible that some
- * implementations persist instances afterwards, but it's equally
- * possible that instances get reused, and as such information
- * may change.
- */
-public interface AttributeInfo
-{
- // // // Generic methods; some duplication from main stream reader
-
- /**
- * @return Number of all attributes accessible (including ones created
- * from the default values, if any) using this Object.
- */
- public int getAttributeCount();
-
- // // // Methods for finding index of specific attributes
-
- /**
- * @return Index of the specified attribute, if the current element
- * has such an attribute (explicit, or one created via default
- * value expansion); -1 if not.
- */
- public int findAttributeIndex(String nsURI, String localName);
-
- /**
- * Returns the index of the id attribute (attribute with any name,
- * type ID from DTD) of current (start) element, if any. Note that
- * DTD only allows at most one such attribute per element.
- *
- * @return Index of the ID attribute of current element,
- * if the current element has such an
- * attribute defined; -1 if not.
- */
- public int getIdAttributeIndex();
-
- /**
- * Returns the index of the notation attribute (attribute with any name,
- * type NOTATION from DTD) of current (start) element, if any. Note that
- * DTD only allows at most one such attribute per element.
- *
- * @return Index of the NOTATION attribute of current element,
- * if the current element has such an
- * attribute defined; -1 if not.
- */
- public int getNotationAttributeIndex();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/DTDInfo.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/DTDInfo.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/DTDInfo.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/DTDInfo.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,59 +0,0 @@
-package org.codehaus.stax2;
-
-import org.codehaus.stax2.validation.DTDValidationSchema;
-
-/**
- * Interface that specifies additional access functionality to parsed DTD
- * information (if any); these methods are encapsulated on a separate
- * interface to keep the main reader interface from exploding.
- *
- * Note: instances of DTDInfo are not guaranteed to persist when the reader
- * that returned it is asked to provide the next event. Some implementations
- * may let it persist, others might not.
- */
-public interface DTDInfo
-{
- // // // Stax2, v1.0
-
- /**
- * @return If current event is DTD, DTD support is enabled,
- * and reader supports DTD processing, returns an internal
- * Object implementation uses for storing/processing DTD;
- * otherwise returns null.
- */
- public Object getProcessedDTD();
-
- /**
- * @return If current event is DTD, returns the full root name
- * (including prefix, if any); otherwise returns null
- */
- public String getDTDRootName();
-
- /**
- * @return If current event is DTD, and has a system id, returns the
- * system id; otherwise returns null.
- */
- public String getDTDSystemId();
-
- /**
- * @return If current event is DTD, and has a public id, returns the
- * public id; otherwise returns null.
- */
- public String getDTDPublicId();
-
- /**
- * @return If current event is DTD, and has an internal subset,
- * returns the internal subset; otherwise returns null.
- */
- public String getDTDInternalSubset();
-
-
- // // // Stax2, v2.0
-
- /**
- * Method similar to {@link #getProcessedDTD}, but type-safe. Will
- * return the DTD schema instance that was read, if we are in mode
- * where it does get read (at least dtd-aware).
- */
- public DTDValidationSchema getProcessedDTDSchema();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/evt/DTD2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/evt/DTD2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/evt/DTD2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/evt/DTD2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,20 +0,0 @@
-package org.codehaus.stax2.evt;
-
-import javax.xml.stream.events.DTD;
-
-/**
- * Interface that extends basic {@link DTD} with methods that are
- * necessary to completely reproduce actual DOCTYPE declaration
- * constructs in xml documents.
- */
-public interface DTD2
- extends DTD
-{
- public String getRootName();
-
- public String getSystemId();
-
- public String getPublicId();
-
- public String getInternalSubset();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/evt/NotationDeclaration2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/evt/NotationDeclaration2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/evt/NotationDeclaration2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/evt/NotationDeclaration2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,14 +0,0 @@
-package org.codehaus.stax2.evt;
-
-import javax.xml.stream.events.NotationDeclaration;
-
-/**
- * Interface that extends basic {@link NotationDeclaration} to add
- * support for handling Base URI needed to resolve Notation references.
- * This
- */
-public interface NotationDeclaration2
- extends NotationDeclaration
-{
- public String getBaseURI();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/evt/XMLEvent2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/evt/XMLEvent2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/evt/XMLEvent2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/evt/XMLEvent2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,21 +0,0 @@
-package org.codehaus.stax2.evt;
-
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.events.XMLEvent;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-
-/**
- * Interface that extends basic {@link XMLEvent2} with method(s)
- * that are missing from it; specifically linkage that allows using
- * a stream/event writer for outputting.
- *
- * NOTE: Unfortunately there is no way to cleanly retrofit this interface
- * to actual implementation classes, so some casting is necessary to
- * make use of new features.
- */
-public interface XMLEvent2
- extends XMLEvent
-{
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/evt/XMLEventFactory2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/evt/XMLEventFactory2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/evt/XMLEventFactory2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/evt/XMLEventFactory2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,23 +0,0 @@
-package org.codehaus.stax2.evt;
-
-import javax.xml.stream.XMLEventFactory;
-
-/**
- * Interface that adds missing (but required) methods to
- * {@link XMLEventFactory}; especially ones for creating actual
- * well-behaving DOCTYPE events.
- */
-public abstract class XMLEventFactory2
- extends XMLEventFactory
-{
- protected XMLEventFactory2() {
- super();
- }
-
- public abstract DTD2 createDTD(String rootName, String sysId, String pubId,
- String intSubset);
-
- public abstract DTD2 createDTD(String rootName, String sysId, String pubId,
- String intSubset, Object processedDTD);
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/EscapingWriterFactory.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/EscapingWriterFactory.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/EscapingWriterFactory.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/EscapingWriterFactory.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,57 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.OutputStream;
-import java.io.UnsupportedEncodingException;
-import java.io.Writer;
-
-/**
- * Interface that defines API for the factories stream writers use for
- * creating "escaping writers". These factories are used when defining
- * custom escaping of text (as well as possibly used by the
- * implementations for default escaping too). Escaping in this context
- * refers to the process of replacing individual text/attribute content
- * character with pre-defined and character entities, as per XML
- * specification (2.4, Appendix D).
- *
- * Typical escaping writers replace characters like '<' and '&',
- * as well as some additional characters depending on context.
- * Custom implementations may choose to escape additional characters,
- * for example to make it easier to manually view or edit resulting
- * serialized XML document.
- *
- * Note about implementing escaping writers: writers need to obey normal
- * Writer semantics, and specifically they should pass calls to
- *
- * Note that no copy is made of the passed-in array, and that further
- * there are direct access methods. Thus, although callers are not
- * to modify contents of returned array, this can not be guaranteed;
- * and as such if this would be a problem (security problem for example),
- * caller has to make a copy of the array and pass that copy to the
- * constructor.
- */
-public class Stax2ByteArraySource
- extends Stax2BlockSource
-{
- private final static String DEFAULT_ENCODING = "UTF-8";
-
- final byte[] mBuffer;
- final int mStart;
- final int mLength;
-
- public Stax2ByteArraySource(byte[] buf, int start, int len)
- {
- mBuffer = buf;
- mStart = start;
- mLength = len;
- }
-
- /*
- /////////////////////////////////////////
- // Implementation of the Public API
- /////////////////////////////////////////
- */
-
- /**
- * Note: if encoding is not explicitly defined, UTF-8 is assumed.
- */
- public Reader constructReader()
- throws IOException
- {
- String enc = getEncoding();
- InputStream in = constructInputStream();
- if (enc == null || enc.length() == 0) {
- /* 11-Nov-2008, TSa: Used to rely on platform default encoding, which
- * doesn't make sense. XML assumes UTF-8 anyway.
- */
- enc = DEFAULT_ENCODING;
- }
- return new InputStreamReader(in, enc);
- }
-
- public InputStream constructInputStream()
- throws IOException
- {
- return new ByteArrayInputStream(mBuffer, mStart, mLength);
- }
-
- /*
- /////////////////////////////////////////
- // Additional API for this source
- /////////////////////////////////////////
- */
-
- public byte[] getBuffer() {
- return mBuffer;
- }
-
- public int getBufferStart() {
- return mStart;
- }
-
- public int getBufferLength() {
- return mLength;
- }
-
- public int getBufferEnd() {
- int end = mStart;
- if (mLength > 0) {
- end += mLength;
- }
- return end;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2CharArraySource.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2CharArraySource.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2CharArraySource.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2CharArraySource.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,68 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-
-/**
- * Simple implementation of {@link Stax2BlockSource} that encapsulates
- * an char array.
- *
- * Note that no copy is made of the passed-in array, and that further
- * there are direct access methods. Thus, although callers are not
- * to modify contents of returned array, this can not be guaranteed;
- * and as such if this would be a problem (security problem for example),
- * caller has to make a copy of the array and pass that copy to the
- * constructor.
- */
-public class Stax2CharArraySource
- extends Stax2BlockSource
-{
- final char[] mBuffer;
- final int mStart;
- final int mLength;
-
- public Stax2CharArraySource(char[] buf, int start, int len)
- {
- mBuffer = buf;
- mStart = start;
- mLength = len;
- }
-
- /*
- /////////////////////////////////////////
- // Implementation of the Public API
- /////////////////////////////////////////
- */
-
- public Reader constructReader()
- throws IOException
- {
- return new CharArrayReader(mBuffer, mStart, mLength);
- }
-
- public InputStream constructInputStream()
- throws IOException
- {
- /* No obvious/easy way; if caller really wants an InputStream, it
- * can get a Reader, add an encoders, and so on.
- */
- return null;
- }
-
- /*
- /////////////////////////////////////////
- // Additional API for this source
- /////////////////////////////////////////
- */
-
- public char[] getBuffer() {
- return mBuffer;
- }
-
- public int getBufferStart() {
- return mStart;
- }
-
- public int getBufferLength() {
- return mLength;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2FileResult.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2FileResult.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2FileResult.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2FileResult.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,50 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-
-/**
- * Simple implementation of {@link Stax2ReferentialResult}, which refers
- * to the specific file.
- */
-public class Stax2FileResult
- extends Stax2ReferentialResult
-{
- final File mFile;
-
- public Stax2FileResult(File f) {
- mFile = f;
- }
-
- /*
- /////////////////////////////////////////
- // Implementation of the Public API
- /////////////////////////////////////////
- */
-
- public Writer constructWriter()
- throws IOException
- {
- String enc = getEncoding();
- if (enc != null && enc.length() > 0) {
- return new OutputStreamWriter(constructOutputStream(), enc);
- }
- // Sub-optimal; really shouldn't use the platform default encoding
- return new FileWriter(mFile);
- }
-
- public OutputStream constructOutputStream()
- throws IOException
- {
- return new FileOutputStream(mFile);
- }
-
- /*
- /////////////////////////////////////////
- // Additional API for this Result
- /////////////////////////////////////////
- */
-
- public File getFile() {
- return mFile;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2FileSource.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2FileSource.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2FileSource.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2FileSource.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,73 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-import java.net.URL;
-
-/**
- * Simple implementation of {@link Stax2ReferentialSource}, which refers
- * to the specific file.
- */
-public class Stax2FileSource
- extends Stax2ReferentialSource
-{
- final File mFile;
-
- public Stax2FileSource(File f) {
- mFile = f;
- }
-
- /*
- /////////////////////////////////////////
- // Implementation of the Public API
- /////////////////////////////////////////
- */
-
- /**
- * @return URL that refers to the reference resource, for the purposes
- * of resolving a relative reference from content read from the
- * resource.
- */
- public URL getReference()
- {
- /* !!! 13-May-2006, TSa: For Woodstox 4.0, consider converting
- * first to URI, then to URL, to ensure that characters in the
- * filename are properly quoted
- */
- try {
- return mFile.toURL();
- } catch (java.net.MalformedURLException e) {
- /* Hmmh. Signature doesn't allow IOException to be thrown. So,
- * let's use something close enough; this should not occur
- * often in practice.
- */
- throw new IllegalArgumentException("(was "+e.getClass()+") Could not convert File '"+mFile.getPath()+"' to URL: "+e);
- }
- }
-
- public Reader constructReader()
- throws IOException
- {
- String enc = getEncoding();
- if (enc != null && enc.length() > 0) {
- return new InputStreamReader(constructInputStream(), enc);
- }
- // Sub-optimal; really shouldn't use the platform default encoding
- return new FileReader(mFile);
- }
-
- public InputStream constructInputStream()
- throws IOException
- {
- return new FileInputStream(mFile);
- }
-
- /*
- /////////////////////////////////////////
- // Additional API for this source
- /////////////////////////////////////////
- */
-
- public File getFile() {
- return mFile;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2ReferentialResult.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2ReferentialResult.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2ReferentialResult.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2ReferentialResult.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,26 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-
-/**
- * This is the mid-level abstract base class for {@link Stax2Result}s
- * that refer to a resource in such a way, that an efficient
- * {@link OutputStream} or {@link Writer} can be constructed.
- *
- * @see Stax2FileResult
- */
-public abstract class Stax2ReferentialResult
- extends Stax2Result
-{
- protected Stax2ReferentialResult() { }
-
- /*
- /////////////////////////////////////////
- // Public API
- /////////////////////////////////////////
- */
-
- public abstract Writer constructWriter() throws IOException;
-
- public abstract OutputStream constructOutputStream() throws IOException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2ReferentialSource.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2ReferentialSource.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2ReferentialSource.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2ReferentialSource.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,53 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-import java.net.URL;
-
-/**
- * This is the mid-level abstract base class for {@link Stax2Source}s
- * that refer to a resource in such a way, that an efficient
- * {@link InputStream} or {@link Reader} can be constructed.
- * Additionally, referenced sources also provide the base URI that allows
- * for resolving relative references from within content read from
- * such resources. Typical examples of references are
- * {@link java.net.URL} and {@link java.io.File}: both for which
- * a default implementations exist in this package
- *
- * @see Stax2FileSource
- * @see Stax2URLSource
- */
-public abstract class Stax2ReferentialSource
- extends Stax2Source
-{
- protected Stax2ReferentialSource() { }
-
- /*
- /////////////////////////////////////////
- // Public API, simple accessors/mutators
- /////////////////////////////////////////
- */
-
- public abstract URL getReference();
-
- public abstract Reader constructReader() throws IOException;
-
- public abstract InputStream constructInputStream() throws IOException;
-
- /*
- /////////////////////////////////////////
- // Overrides
- /////////////////////////////////////////
- */
-
- /**
- * Since we can determine a system id from the base URL
- */
- public String getSystemId()
- {
- String sysId = super.getSystemId();
- if (sysId == null) {
- sysId = getReference().toExternalForm();
- }
- return sysId;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2Result.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2Result.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2Result.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2Result.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,99 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.OutputStream;
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.transform.Result;
-
-/**
- * This is the base class for additional output results (implementations
- * of {@link javax.xml.transform.Result}) that Stax2
- * {@link org.codehaus.stax2.XMLInputFactory2} implementations should support.
- *
- * Note about usage by the parser factory implementations: the expectation
- * is that at least one of methods {@link #constructWriter} and
- * {@link #constructOutputStream} will succeed, but not necessarily both.
- * This generally depends on type of resource being represented: for example,
- * if the source is a StringBuffer, it is most naturally
- * represent via {@link Writer}. For File-backed results, on the other hand,
- * an {@link OutputStream} is the most natural access method.
- *
- * Other things to note about using result {@link Writer}s and
- * {@link OutputStream}s:
- *
- * Note about usage by the parser factory implementations: the expectation
- * is that at least one of methods {@link #constructReader} and
- * {@link #constructInputStream} will succeed, but not necessarily both.
- * This generally depends on type of resource being represented: for example,
- * if the source is a String or character array, it is most naturally
- * represent via {@link Reader}. For a byte array, on the other hand,
- * an {@link InputStream} is the most natural access method.
- *
- * Other things to note about using result {@link Reader}s and
- * {@link InputStream}s:
- *
- * Note: instances of LocationInfo are only guaranteed to persist as long
- * as the (stream) reader points to the current element (whatever it is).
- * After next call to
- * Note: this value MAY be the same as the one returned by
- * {@link #getStartingCharOffset}, but usually only for single-byte
- * character streams (Ascii, ISO-Latin).
- *
- * @return Byte offset (== number of bytes reader so far) within the
- * underlying stream, if the stream and stream reader are able to
- * provide this (separate from the character offset, for variable-byte
- * encodings); -1 if not.
- */
- public long getStartingByteOffset();
-
- /**
- * Method that can be used to get exact character offset (number of chars
- * read from the stream right before getting to this location) in the
- * stream that is pointed to by this reader, right before the start
- * of the current event.
- *
- * Note: this value MAY be the same as the one returned by
- * {@link #getStartingByteOffset}; this is the case for single-byte
- * character streams (Ascii, ISO-Latin), as well as for streams for
- * which byte offset information is not available (Readers, Strings).
- *
- * @return Character offset (== number of bytes reader so far) within the
- * underlying stream, if the stream and stream reader are able to
- * provide this (separate from byte offset, for variable-byte
- * encodings); -1 if not.
- */
- public long getStartingCharOffset();
-
- /**
- * Method that can be used to get exact byte offset (number of bytes
- * read from the stream right before getting to this location) in the
- * stream that is pointed to by this reader, right after the end
- * of the current event.
- *
- * Note: this value MAY be the same as the one returned by
- * {@link #getEndingCharOffset}, but usually only for single-byte
- * character streams (Ascii, ISO-Latin).
- *
- * Note: for lazy-loading implementations, calling this method may
- * require the underlying stream to be advanced and contents parsed;
- * this is why it is possible that an exception be thrown.
- *
- * @return Byte offset (== number of bytes reader so far) within the
- * underlying stream, if the stream and stream reader are able to
- * provide this (separate from the character offset, for variable-byte
- * encodings); -1 if not.
- */
- public long getEndingByteOffset()
- throws XMLStreamException;
-
- /**
- * Method that can be used to get exact character offset (number of chars
- * read from the stream right before getting to this location) in the
- * stream that is pointed to by this reader, right after the end
- * of the current event.
- *
- * Note: this value MAY be the same as the one returned by
- * {@link #getEndingByteOffset}; this is the case for single-byte
- * character streams (Ascii, ISO-Latin), as well as for streams for
- * which byte offset information is not available (Readers, Strings).
- *
- * Note: for lazy-loading implementations, calling this method may
- * require the underlying stream to be advanced and contents parsed;
- * this is why it is possible that an exception be thrown.
- *
- * @return Character offset (== number of bytes reader so far) within the
- * underlying stream, if the stream and stream reader are able to
- * provide this (separate from byte offset, for variable-byte
- * encodings); -1 if not.
- */
- public long getEndingCharOffset()
- throws XMLStreamException;
-
- /*
- /////////////////////////////////////////////////////
- // Object-oriented location access methods
- /////////////////////////////////////////////////////
- */
-
- // // // Existing method from XMLStreamReader:
-
- public Location getLocation();
-
- // // // New methods:
-
- /**
- * An optional method that either returns the location object that points the
- * starting position of the current event, or null if implementation
- * does not keep track of it (some may return only end location; and
- * some no location at all).
- *
- * Note: since it is assumed that the start location must either have
- * been collected by now, or is not accessible (i.e. implementation
- * [always] returns null), no exception is allowed to be throws, as
- * no parsing should ever need to be done (unlike with
- * {@link #getEndLocation}).
- *
- * @return Location of the first character of the current event in
- * the input source (which will also be the starting location
- * of the following event, if any, or EOF if not), or null (if
- * implementation does not track locations).
- */
- public XMLStreamLocation2 getStartLocation();
-
- /**
- * A method that returns the current location of the stream reader
- * at the input source. This is somewhere between the start
- * and end locations (inclusive), depending on how parser does it
- * parsing (for non-lazy implementations it's always the end location;
- * for others something else).
- *
- * Since this location information should always be accessible, no
- * further parsing is to be done, and no exceptions can be thrown.
- *
- * @return Location of the next character reader will parse in the
- * input source.
- */
- public XMLStreamLocation2 getCurrentLocation();
-
- /**
- * An optional method that either returns the location object that points the
- * ending position of the current event, or null if implementation
- * does not keep track of it (some may return only start location; and
- * some no location at all).
- *
- * Note: since some implementations may not yet know the end location
- * (esp. ones that do lazy loading), this call may require further
- * parsing. As a result, this method may throw a parsing or I/O
- * errors.
- *
- * @return Location right after the end
- * of the current event (which will also be the start location of
- * the next event, if any, or of EOF otherwise).
- *
- * @throws XMLStreamException If the stream reader had to advance to
- * the end of the event (to find the location), it may encounter a
- * parsing (or I/O) error; if so, that gets thrown
- */
- public XMLStreamLocation2 getEndLocation()
- throws XMLStreamException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/osgi/Stax2InputFactoryProvider.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/osgi/Stax2InputFactoryProvider.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/osgi/Stax2InputFactoryProvider.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/osgi/Stax2InputFactoryProvider.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,53 +0,0 @@
-package org.codehaus.stax2.osgi;
-
-import org.codehaus.stax2.XMLInputFactory2;
-import org.codehaus.stax2.XMLStreamProperties;
-
-/**
- * Simple interface to be used for registering objects that
- * can construct {@link XMLInputFactory2} instances with OSGi framework.
- * The added indirection (provider constructing factory) is needed because
- * of impedance between OSGi service objects (which are essentially
- * singletons) and Stax/Stax2 factories which are not.
- *
- * Note: implementations of provider should NOT use introspection
- * via {@link javax.xml.stream.XMLInputFactory#newInstance} as it will
- * not work with OSGi. Instead, providers should directly construct
- * instances of concrete factory they represent. That is, there will
- * be one provider implementation per concrete Stax/Stax2 implementation
- */
-public interface Stax2InputFactoryProvider
-{
- /*
- ///////////////////////////////////////////////////////////////
- // Service property names to use with the provider
- ///////////////////////////////////////////////////////////////
- */
-
- /**
- * Service property that defines name of Stax2 implementation that
- * this provider represents.
- */
- public final static String OSGI_SVC_PROP_IMPL_NAME = XMLStreamProperties.XSP_IMPLEMENTATION_NAME;
-
- /**
- * Service property that defines version of Stax2 implementation that
- * this provider represents.
- */
- public final static String OSGI_SVC_PROP_IMPL_VERSION = XMLStreamProperties.XSP_IMPLEMENTATION_VERSION;
-
- /*
- ///////////////////////////////////////////////////////////////
- // Public provider API
- ///////////////////////////////////////////////////////////////
- */
-
- /**
- * Method called to create a new {@link XMLInputFactory2} instance.
- *
- * @return Input factory configured to implementation-specific
- * default settings (some of which are mandated by Stax and Stax2
- * specifications)
- */
- public XMLInputFactory2 createInputFactory();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/osgi/Stax2OutputFactoryProvider.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/osgi/Stax2OutputFactoryProvider.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/osgi/Stax2OutputFactoryProvider.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/osgi/Stax2OutputFactoryProvider.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,53 +0,0 @@
-package org.codehaus.stax2.osgi;
-
-import org.codehaus.stax2.XMLOutputFactory2;
-import org.codehaus.stax2.XMLStreamProperties;
-
-/**
- * Simple interface to be used for registering objects that
- * can construct {@link XMLOutputFactory2} instances with OSGi framework.
- * The added indirection (provider constructing factory) is needed because
- * of impedance between OSGi service objects (which are essentially
- * singletons) and Stax/Stax2 factories which are not.
- *
- * Note: implementations of provider should NOT use introspection
- * via {@link javax.xml.stream.XMLOutputFactory#newInstance} as it will
- * not work with OSGi. Instead, providers should directly construct
- * instances of concrete factory they represent. That is, there will
- * be one provider implementation per concrete Stax/Stax2 implementation
- */
-public interface Stax2OutputFactoryProvider
-{
- /*
- ///////////////////////////////////////////////////////////////
- // Service property names to use with the provider
- ///////////////////////////////////////////////////////////////
- */
-
- /**
- * Service property that defines name of Stax2 implementation that
- * this provider represents.
- */
- public final static String OSGI_SVC_PROP_IMPL_NAME = XMLStreamProperties.XSP_IMPLEMENTATION_NAME;
-
- /**
- * Service property that defines version of Stax2 implementation that
- * this provider represents.
- */
- public final static String OSGI_SVC_PROP_IMPL_VERSION = XMLStreamProperties.XSP_IMPLEMENTATION_VERSION;
-
- /*
- ///////////////////////////////////////////////////////////////
- // Public provider API
- ///////////////////////////////////////////////////////////////
- */
-
- /**
- * Method called to create a new {@link XMLOutputFactory2} instance.
- *
- * @return Output factory configured to implementation-specific
- * default settings (some of which are mandated by Stax and Stax2
- * specifications)
- */
- public XMLOutputFactory2 createOutputFactory();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/osgi/Stax2ValidationSchemaFactoryProvider.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/osgi/Stax2ValidationSchemaFactoryProvider.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/osgi/Stax2ValidationSchemaFactoryProvider.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/osgi/Stax2ValidationSchemaFactoryProvider.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,77 +0,0 @@
-package org.codehaus.stax2.osgi;
-
-import org.codehaus.stax2.XMLStreamProperties;
-import org.codehaus.stax2.validation.XMLValidationSchemaFactory;
-
-/**
- * Simple interface to be used for registering objects that
- * can construct {@link XMLValidationSchemaFactory} instances with OSGi framework.
- * The added indirection (provider constructing factory) is needed because
- * of impedance between OSGi service objects (which are essentially
- * singletons) and Stax/Stax2 factories which are not.
- *
- * Note: implementations of provider should NOT use introspection
- * via {@link XMLValidationSchemaFactory#newInstance} as it will
- * not work with OSGi. Instead, providers should directly construct
- * instances of concrete factory they represent. That is, there will
- * be one provider implementation per concrete Stax/Stax2 implementation
- */
-public interface Stax2ValidationSchemaFactoryProvider
-{
- /*
- ///////////////////////////////////////////////////////////////
- // Service property names to use with the provider
- ///////////////////////////////////////////////////////////////
- */
-
- /**
- * Service property that defines name of Stax2 implementation that
- * this provider represents.
- */
- public final static String OSGI_SVC_PROP_IMPL_NAME = XMLStreamProperties.XSP_IMPLEMENTATION_NAME;
-
- /**
- * Service property that defines version of Stax2 implementation that
- * this provider represents.
- */
- public final static String OSGI_SVC_PROP_IMPL_VERSION = XMLStreamProperties.XSP_IMPLEMENTATION_VERSION;
-
- /**
- * Service property that defines type of Schemas (one of constants from
- * {@link org.codehaus.stax2.validation.XMLValidationSchema},
- * such as {@link org.codehaus.stax2.validation.XMLValidationSchema#SCHEMA_ID_DTD})
- * that the schema factory this provider handles supports. Can be used
- * to locate proper provider for the schema type.
- */
- public final static String OSGI_SVC_PROP_SCHEMA_TYPE = "org.codehaus.stax2.validation.schemaType";
-
- /*
- ///////////////////////////////////////////////////////////////
- // Public provider API
- ///////////////////////////////////////////////////////////////
- */
-
- /**
- * Method that can be used to determine which schema type this
- * provider (or, rather, factory instances of which provider
- * constructs) supports.
- *
- * @return Id of schema type that the factory instantiated by this
- * provider will support.
- */
- public String getSchemaType();
-
- /**
- * Method called to create a new {@link XMLValidationSchemaFactory}
- * instance. Each schema factory supports a single schema type;
- * so caller has to ensure that the factory it is using supports
- * schema it needs to instantiate. This can be done either by using
- * service properties, or by inspecting provider instances for
- * schema type they support (see {@link #getSchemaType}).
- *
- * @return ValidationSchema factory configured to implementation-specific
- * default settings, if type is supported by this provider; null
- * if not.
- */
- public XMLValidationSchemaFactory createValidationSchemaFactory();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/dom/DOMWrappingReader.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/dom/DOMWrappingReader.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/dom/DOMWrappingReader.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/dom/DOMWrappingReader.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,2264 +0,0 @@
-/* Stax2 API extension for Streaming API for XML processing (StAX).
- *
- * Copyright (c) 2006- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in the file LICENSE which is
- * included with the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.dom;
-
-import java.io.IOException;
-import java.io.Writer;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.*;
-
-import javax.xml.transform.dom.DOMSource;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-
-import org.w3c.dom.*;
-
-import org.codehaus.stax2.AttributeInfo;
-import org.codehaus.stax2.DTDInfo;
-import org.codehaus.stax2.LocationInfo;
-import org.codehaus.stax2.XMLStreamLocation2;
-import org.codehaus.stax2.XMLStreamReader2;
-import org.codehaus.stax2.ri.EmptyIterator;
-import org.codehaus.stax2.ri.EmptyNamespaceContext;
-import org.codehaus.stax2.ri.SingletonIterator;
-import org.codehaus.stax2.ri.Stax2Util;
-import org.codehaus.stax2.ri.typed.StringBase64Decoder;
-import org.codehaus.stax2.ri.typed.ValueDecoderFactory;
-import org.codehaus.stax2.typed.Base64Variant;
-import org.codehaus.stax2.typed.Base64Variants;
-import org.codehaus.stax2.typed.TypedArrayDecoder;
-import org.codehaus.stax2.typed.TypedValueDecoder;
-import org.codehaus.stax2.typed.TypedXMLStreamException;
-import org.codehaus.stax2.validation.DTDValidationSchema;
-import org.codehaus.stax2.validation.ValidationProblemHandler;
-import org.codehaus.stax2.validation.XMLValidationSchema;
-import org.codehaus.stax2.validation.XMLValidator;
-
-/**
- * This is an adapter class that presents a DOM document as if it was
- * a regular {@link XMLStreamReader}. This is mostly useful for
- * inter-operability purposes, and should only be used when the
- * input has to come as a DOM object and the original xml content
- * is not available as a stream.
- *
- * Note that the implementation is only to be used for use with
- *
- * Some notes regarding missing/incomplete functionality:
- *
- */
- protected List _attrList = null;
-
- /**
- * Lazily instantiated String pairs of all namespace declarations for the
- * current (start/end) element. String pair means that for each
- * declarations there are two Strings in the list: first one is prefix
- * (empty String for the default namespace declaration), and second
- * URI it is bound to.
- */
- protected List _nsDeclList = null;
-
- /**
- * Factory used for constructing decoders we need for typed access
- */
- protected ValueDecoderFactory _decoderFactory;
-
- /**
- * Lazily-constructed decoder object for decoding base64 encoded
- * binary content.
- */
- protected StringBase64Decoder _base64Decoder = null;
-
- /*
- ////////////////////////////////////////////////////
- // Construction, configuration
- ////////////////////////////////////////////////////
- */
-
- /**
- * @param src Node that is the tree of the DOM document, or fragment.
- * @param nsAware Whether resulting reader should operate in namespace
- * aware mode or not. Note that this should be compatible with
- * settings for the DOM builder that produced DOM tree or fragment
- * being operated on, otherwise results are not defined.
- * @param coalescing Whether resulting reader should coalesce adjacent
- * text events or not
- */
- protected DOMWrappingReader(DOMSource src, boolean nsAware, boolean coalescing)
- throws XMLStreamException
- {
- Node treeRoot = src.getNode();
- if (treeRoot == null) {
- throw new IllegalArgumentException("Can not pass null Node for constructing a DOM-based XMLStreamReader");
- }
- _cfgNsAware = nsAware;
- _coalescing = coalescing;
- _systemId = src.getSystemId();
-
- /* Ok; we need a document node; or an element node; or a document
- * fragment node.
- */
- switch (treeRoot.getNodeType()) {
- case Node.DOCUMENT_NODE: // fine
- /* Should try to find encoding, version and stand-alone
- * settings... but is there a standard way of doing that?
- */
- case Node.ELEMENT_NODE: // can make sub-tree... ok
- // But should we skip START/END_DOCUMENT? For now, let's not
-
- case Node.DOCUMENT_FRAGMENT_NODE: // as with element...
-
- // Above types are fine
- break;
-
- default: // other Nodes not usable
- throw new XMLStreamException("Can not create an XMLStreamReader for a DOM node of type "+treeRoot.getClass());
- }
- _rootNode = _currNode = treeRoot;
- }
-
- protected void setInternNames(boolean state) { _cfgInternNames = state; }
- protected void setInternNsURIs(boolean state) { _cfgInternNsURIs = state; }
-
- /*
- ////////////////////////////////////////////////////
- // Abstract methods for sub-classes to implement
- ////////////////////////////////////////////////////
- */
-
- protected abstract void throwStreamException(String msg, Location loc)
- throws XMLStreamException;
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamReader, document info
- ////////////////////////////////////////////////////
- */
-
- /**
- * As per Stax (1.0) specs, needs to return whatever xml declaration
- * claimed encoding is, if any; or null if no xml declaration found.
- */
- public String getCharacterEncodingScheme() {
- /* No standard way to figure it out from a DOM Document node;
- * have to return null
- */
- return null;
- }
-
- /**
- * As per Stax (1.0) specs, needs to return whatever parser determined
- * the encoding was, if it was able to figure it out. If not (there are
- * cases where this can not be found; specifically when being passed a
- * {@link java.io.Reader}), it should return null.
- */
- public String getEncoding() {
- /* We have no information regarding underlying stream/Reader, so
- * best we can do is to see if we know xml declaration encoding.
- */
- return getCharacterEncodingScheme();
- }
-
- public String getVersion()
- {
- /* No standard way to figure it out from a DOM Document node;
- * have to return null
- */
- return null;
- }
-
- public boolean isStandalone() {
- /* No standard way to figure it out from a DOM Document node;
- * have to return false
- */
- return false;
- }
-
- public boolean standaloneSet() {
- /* No standard way to figure it out from a DOM Document node;
- * have to return false
- */
- return false;
- }
-
- /*
- ////////////////////////////////////////////////////
- // Public API, configuration
- ////////////////////////////////////////////////////
- */
-
- public abstract Object getProperty(String name);
-
- // NOTE: getProperty() defined in Stax 1.0 interface
-
- public abstract boolean isPropertySupported(String name);
-
- /**
- * @param name Name of the property to set
- * @param value Value to set property to.
- *
- * @return True, if the specified property was succesfully
- * set to specified value; false if its value was not changed
- */
- public abstract boolean setProperty(String name, Object value);
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamReader, current state
- ////////////////////////////////////////////////////
- */
-
- // // // Attribute access:
-
- public int getAttributeCount()
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- if (_attrList == null) {
- _calcNsAndAttrLists(true);
- }
- return _attrList.size();
- }
-
- public String getAttributeLocalName(int index)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- if (_attrList == null) {
- _calcNsAndAttrLists(true);
- }
- if (index >= _attrList.size() || index < 0) {
- handleIllegalAttrIndex(index);
- return null;
- }
- Attr attr = (Attr) _attrList.get(index);
- return _internName(_safeGetLocalName(attr));
- }
-
- public QName getAttributeName(int index)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- if (_attrList == null) {
- _calcNsAndAttrLists(true);
- }
- if (index >= _attrList.size() || index < 0) {
- handleIllegalAttrIndex(index);
- return null;
- }
- Attr attr = (Attr) _attrList.get(index);
- return _constructQName(attr.getNamespaceURI(), _safeGetLocalName(attr), attr.getPrefix());
- }
-
- public String getAttributeNamespace(int index)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- if (_attrList == null) {
- _calcNsAndAttrLists(true);
- }
- if (index >= _attrList.size() || index < 0) {
- handleIllegalAttrIndex(index);
- return null;
- }
- Attr attr = (Attr) _attrList.get(index);
- return _internNsURI(attr.getNamespaceURI());
- }
-
- public String getAttributePrefix(int index)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- if (_attrList == null) {
- _calcNsAndAttrLists(true);
- }
- if (index >= _attrList.size() || index < 0) {
- handleIllegalAttrIndex(index);
- return null;
- }
- Attr attr = (Attr) _attrList.get(index);
- return _internName(attr.getPrefix());
- }
-
- public String getAttributeType(int index)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- if (_attrList == null) {
- _calcNsAndAttrLists(true);
- }
- if (index >= _attrList.size() || index < 0) {
- handleIllegalAttrIndex(index);
- return null;
- }
- //Attr attr = (Attr) _attrList.get(index);
- // First, a special case, ID... since it's potentially most useful
- /* 26-Apr-2006, TSa: Turns out that following methods are
- * DOM Level3, and as such not available in JDK 1.4 and prior.
- * Thus, let's not yet use them (could use dynamic discovery
- * for graceful downgrade)
- */
- /*
- if (attr.isId()) {
- return "ID";
- }
- TypeInfo schemaType = attr.getSchemaTypeInfo();
- return (schemaType == null) ? "CDATA" : schemaType.getTypeName();
- */
- return "CDATA";
- }
-
- public String getAttributeValue(int index)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- if (_attrList == null) {
- _calcNsAndAttrLists(true);
- }
- if (index >= _attrList.size() || index < 0) {
- handleIllegalAttrIndex(index);
- return null;
- }
- Attr attr = (Attr) _attrList.get(index);
- return attr.getValue();
- }
-
- public String getAttributeValue(String nsURI, String localName)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- Element elem = (Element) _currNode;
- NamedNodeMap attrs = elem.getAttributes();
- /* Hmmh. DOM javadocs claim "Per [XML Namespaces], applications
- * must use the value null as the namespaceURI parameter for methods
- * if they wish to have no namespace.".
- * Not sure how true that is, but:
- */
- if (nsURI != null && nsURI.length() == 0) {
- nsURI = null;
- }
- Attr attr = (Attr) attrs.getNamedItemNS(nsURI, localName);
- return (attr == null) ? null : attr.getValue();
- }
-
- /**
- * From StAX specs:
- *
- * Note: as per StAX 1.0 specs, this method does NOT close the underlying
- * input reader. That is, unless the new StAX2 property
- * {@link org.codehaus.stax2.XMLInputFactory2#P_AUTO_CLOSE_INPUT} is
- * set to true.
- */
- public void close()
- throws XMLStreamException
- {
- // Since DOM tree has no real input source, nothing to do
- }
-
-
- /*
- ////////////////////////////////////////////////////
- // NamespaceContext
- ////////////////////////////////////////////////////
- */
-
- public String getNamespaceURI(String prefix)
- {
- /* !!! 26-Apr-2006, TSa: Alas, these methods are DOM Level 3,
- * i.e. require JDK 1.5 or higher
- */
- /*
- if (prefix.length() == 0) { // def NS
- return _currNode.lookupNamespaceURI(null);
- }
- return _currNode.lookupNamespaceURI(prefix);
- */
- return null;
- }
-
- public String getPrefix(String namespaceURI)
- {
- /* !!! 26-Apr-2006, TSa: Alas, these methods are DOM Level 3,
- * i.e. require JDK 1.5 or higher
- */
- /*
- String prefix = _currNode.lookupPrefix(namespaceURI);
- if (prefix == null) { // maybe default NS?
- String defURI = _currNode.lookupNamespaceURI(null);
- if (defURI != null && defURI.equals(namespaceURI)) {
- return "";
- }
- }
- return prefix;
- */
- return null;
- }
-
- public Iterator getPrefixes(String namespaceURI)
- {
- String prefix = getPrefix(namespaceURI);
- if (prefix == null) {
- return EmptyIterator.getInstance();
- }
- return new SingletonIterator(prefix);
- }
-
- /*
- /////////////////////////////////////////////////
- // TypedXMLStreamReader2 implementation, element
- /////////////////////////////////////////////////
- */
-
- public boolean getElementAsBoolean() throws XMLStreamException
- {
- ValueDecoderFactory.BooleanDecoder dec = _decoderFactory().getBooleanDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public int getElementAsInt() throws XMLStreamException
- {
- ValueDecoderFactory.IntDecoder dec = _decoderFactory().getIntDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public long getElementAsLong() throws XMLStreamException
- {
- ValueDecoderFactory.LongDecoder dec = _decoderFactory().getLongDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public float getElementAsFloat() throws XMLStreamException
- {
- ValueDecoderFactory.FloatDecoder dec = _decoderFactory().getFloatDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public double getElementAsDouble() throws XMLStreamException
- {
- ValueDecoderFactory.DoubleDecoder dec = _decoderFactory().getDoubleDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public BigInteger getElementAsInteger() throws XMLStreamException
- {
- ValueDecoderFactory.IntegerDecoder dec = _decoderFactory().getIntegerDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public BigDecimal getElementAsDecimal() throws XMLStreamException
- {
- ValueDecoderFactory.DecimalDecoder dec = _decoderFactory().getDecimalDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public QName getElementAsQName() throws XMLStreamException
- {
- ValueDecoderFactory.QNameDecoder dec = _decoderFactory().getQNameDecoder(getNamespaceContext());
- getElementAs(dec);
- return dec.getValue();
- }
-
- public byte[] getElementAsBinary() throws XMLStreamException
- {
- return getElementAsBinary(Base64Variants.getDefaultVariant());
- }
-
- public byte[] getElementAsBinary(Base64Variant v) throws XMLStreamException
- {
- // note: code here is similar to Base64DecoderBase.aggregateAll(), see comments there
- Stax2Util.ByteAggregator aggr = _base64Decoder().getByteAggregator();
- byte[] buffer = aggr.startAggregation();
- while (true) {
- int offset = 0;
- int len = buffer.length;
- do {
- int readCount = readElementAsBinary(buffer, offset, len, v);
- if (readCount < 1) { // all done!
- return aggr.aggregateAll(buffer, offset);
- }
- offset += readCount;
- len -= readCount;
- } while (len > 0);
- buffer = aggr.addFullBlock(buffer);
- }
- }
-
- public void getElementAs(TypedValueDecoder tvd) throws XMLStreamException
- {
- String value = getElementText();
- value = Stax2Util.trimSpaces(value);
- try {
- if (value == null) {
- tvd.handleEmptyValue();
- } else {
- tvd.decode(value);
- }
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, value);
- }
- }
-
- public int readElementAsIntArray(int[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getIntArrayDecoder(value, from, length));
- }
-
- public int readElementAsLongArray(long[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getLongArrayDecoder(value, from, length));
- }
-
- public int readElementAsFloatArray(float[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getFloatArrayDecoder(value, from, length));
- }
-
- public int readElementAsDoubleArray(double[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getDoubleArrayDecoder(value, from, length));
- }
-
- public int readElementAsArray(TypedArrayDecoder tad) throws XMLStreamException
- {
- /* Otherwise either we are just starting (START_ELEMENT), or
- * have collected all the stuff into _textBuffer.
- */
- if (_currEvent == START_ELEMENT) {
- // One special case, no children:
- Node fc = _currNode.getFirstChild();
- if (fc == null) {
- _currEvent = END_ELEMENT;
- return -1;
- }
- _coalescedText = coalesceTypedText(fc);
- _currEvent = CHARACTERS;
- _currNode = _currNode.getLastChild();
- } else {
- if (_currEvent != CHARACTERS && _currEvent != CDATA) {
- // Maybe we are already done?
- if (_currEvent == END_ELEMENT) {
- return -1;
- }
- reportWrongState(ERR_STATE_NOT_TEXTUAL_OR_ELEM);
- }
- /* One more thing: do we have the data? It is possible
- * that caller has advanced to this text node by itself.
- * We could handle this mostly ok; but that is not a supported
- * use case as per Typed Access API definition (as it can not
- * be reliably supported by all implementations), so:
- */
- if (_coalescedText == null) {
- throw new IllegalStateException("First call to readElementAsArray() must be for a START_ELEMENT, not directly for a textual event");
- }
- }
- /* Otherwise, need to move pointer to point to the last
- * child node, and fake that it was a textual node
- */
- // Ok, so what do we have left?
- String input = _coalescedText;
- final int end = input.length();
- int ptr = 0;
- int count = 0;
- String value = null;
-
- try {
- decode_loop:
- while (ptr < end) {
- // First, any space to skip?
- while (input.charAt(ptr) <= INT_SPACE) {
- if (++ptr >= end) {
- break decode_loop;
- }
- }
- // Then let's figure out non-space char (token)
- int start = ptr;
- ++ptr;
- while (ptr < end && input.charAt(ptr) > INT_SPACE) {
- ++ptr;
- }
- ++count;
- // And there we have it
- value = input.substring(start, ptr);
- // Plus, can skip trailing space (or at end, just beyond it)
- ++ptr;
- if (tad.decodeValue(value)) {
- break;
- }
- }
- } catch (IllegalArgumentException iae) {
- // Need to convert to a checked stream exception
- /* Hmmh. This is not an accurate location... but it's
- * about the best we can do
- */
- Location loc = getLocation();
- throw new TypedXMLStreamException(value, iae.getMessage(), loc, iae);
- } finally {
- int len = end-ptr;
- _coalescedText = (len < 1) ? "" : input.substring(ptr);
- }
-
- if (count < 1) { // end
- _currEvent = END_ELEMENT;
- _currNode = _currNode.getParentNode();
- return -1;
- }
- return count;
- }
-
- private String coalesceTypedText(Node firstNode)
- throws XMLStreamException
- {
- /* This is a bit tricky as we have to collect all the
- * text up end tag, but can not advance to END_ELEMENT
- * event itself (except if there is no content)
- */
- _textBuffer.reset();
- _attrList = null; // so it will not get reused accidentally
-
- for (Node n = firstNode; n != null; n = n.getNextSibling()) {
- switch (n.getNodeType()) {
- case Node.ELEMENT_NODE:
- // Illegal to have child elements...
- throwStreamException("Element content can not contain child START_ELEMENT when using Typed Access methods");
- case Node.CDATA_SECTION_NODE:
- case Node.TEXT_NODE:
- _textBuffer.append(n.getNodeValue());
- break;
-
- case Node.COMMENT_NODE:
- case Node.PROCESSING_INSTRUCTION_NODE:
- break;
-
- default:
- // Otherwise... do we care? For now, let's do
- throwStreamException("Unexpected DOM node type ("+n.getNodeType()+") when trying to decode Typed content");
- }
- }
- return _textBuffer.get();
- }
-
- /*
- ////////////////////////////////////////////////////////
- // TypedXMLStreamReader2 implementation, binary data
- ////////////////////////////////////////////////////////
- */
-
- public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength)
- throws XMLStreamException
- {
- return readElementAsBinary(resultBuffer, offset, maxLength, Base64Variants.getDefaultVariant());
- }
-
- public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength,
- Base64Variant v)
- throws XMLStreamException
- {
- if (resultBuffer == null) {
- throw new IllegalArgumentException("resultBuffer is null");
- }
- if (offset < 0) {
- throw new IllegalArgumentException("Illegal offset ("+offset+"), must be [0, "+resultBuffer.length+"[");
- }
- if (maxLength < 1 || (offset + maxLength) > resultBuffer.length) {
- if (maxLength == 0) { // special case, allowed, but won't do anything
- return 0;
- }
- throw new IllegalArgumentException("Illegal maxLength ("+maxLength+"), has to be positive number, and offset+maxLength can not exceed"+resultBuffer.length);
- }
-
- final StringBase64Decoder dec = _base64Decoder();
- int type = _currEvent;
- // First things first: must be acceptable start state:
- if (((1 << type) & MASK_TYPED_ACCESS_BINARY) == 0) {
- if (type == END_ELEMENT) {
- // Minor complication: may have unflushed stuff (non-padded versions)
- if (!dec.hasData()) {
- return -1;
- }
- } else {
- reportWrongState(ERR_STATE_NOT_TEXTUAL_OR_ELEM);
- }
- }
-
- // Are we just starting (START_ELEMENT)?
- if (type == START_ELEMENT) {
- // Just need to locate the first text segment (or reach END_ELEMENT)
- while (true) {
- type = next();
- if (type == END_ELEMENT) {
- // Simple... no textual content
- return -1;
- }
- if (type == COMMENT || type == PROCESSING_INSTRUCTION) {
- continue;
- }
- if (((1 << type) & MASK_GET_ELEMENT_TEXT) == 0) {
- reportParseProblem(ERR_STATE_NOT_TEXTUAL);
- }
- dec.init(v, true, getText());
- break;
- }
- }
-
- int totalCount = 0;
-
- main_loop:
- while (true) {
- // Ok, decode:
- int count;
- try {
- count = dec.decode(resultBuffer, offset, maxLength);
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, "");
- }
- offset += count;
- totalCount += count;
- maxLength -= count;
-
- /* And if we filled the buffer we are done. Or, an edge
- * case: reached END_ELEMENT (for non-padded variant)
- */
- if (maxLength < 1 || _currEvent == END_ELEMENT) {
- break;
- }
- // Otherwise need to advance to the next event
- while (true) {
- type = next();
- if (type == COMMENT || type == PROCESSING_INSTRUCTION
- || type == SPACE) { // space is ignorable too
- continue;
- }
- if (type == END_ELEMENT) {
- /* Just need to verify we don't have partial stuff
- * (missing one to three characters of a full quartet
- * that encodes 1 - 3 bytes). Also: non-padding
- * variants can be in incomplete state, from which
- * data may need to be flushed...
- */
- int left = dec.endOfContent();
- if (left < 0) { // incomplete, error
- throw _constructTypeException("Incomplete base64 triplet at the end of decoded content", "");
- } else if (left > 0) { // 1 or 2 more bytes of data, loop some more
- continue main_loop;
- }
- // Otherwise, no more data, we are done
- break main_loop;
- }
- if (((1 << type) & MASK_GET_ELEMENT_TEXT) == 0) {
- reportParseProblem(ERR_STATE_NOT_TEXTUAL);
- }
- dec.init(v, false, getText());
- break;
- }
- }
-
- // If nothing was found, needs to be indicated via -1, not 0
- return (totalCount > 0) ? totalCount : -1;
- }
-
- /*
- /////////////////////////////////////////////////
- // TypedXMLStreamReader2 implementation, attribute
- /////////////////////////////////////////////////
- */
-
- public int getAttributeIndex(String namespaceURI, String localName)
- {
- return findAttributeIndex(namespaceURI, localName);
- }
-
- public boolean getAttributeAsBoolean(int index) throws XMLStreamException
- {
- ValueDecoderFactory.BooleanDecoder dec = _decoderFactory().getBooleanDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public int getAttributeAsInt(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntDecoder dec = _decoderFactory().getIntDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public long getAttributeAsLong(int index) throws XMLStreamException
- {
- ValueDecoderFactory.LongDecoder dec = _decoderFactory().getLongDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public float getAttributeAsFloat(int index) throws XMLStreamException
- {
- ValueDecoderFactory.FloatDecoder dec = _decoderFactory().getFloatDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public double getAttributeAsDouble(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DoubleDecoder dec = _decoderFactory().getDoubleDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public BigInteger getAttributeAsInteger(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntegerDecoder dec = _decoderFactory().getIntegerDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public BigDecimal getAttributeAsDecimal(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DecimalDecoder dec = _decoderFactory().getDecimalDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public QName getAttributeAsQName(int index) throws XMLStreamException
- {
- ValueDecoderFactory.QNameDecoder dec = _decoderFactory().getQNameDecoder(getNamespaceContext());
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public final void getAttributeAs(int index, TypedValueDecoder tvd) throws XMLStreamException
- {
- String value = getAttributeValue(index);
- value = Stax2Util.trimSpaces(value);
- try {
- if (value == null) {
- tvd.handleEmptyValue();
- } else {
- tvd.decode(value);
- }
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, value);
- }
- }
-
- public int[] getAttributeAsIntArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntArrayDecoder dec = _decoderFactory().getIntArrayDecoder();
- _getAttributeAsArray(dec, getAttributeValue(index));
- return dec.getValues();
- }
-
- public long[] getAttributeAsLongArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.LongArrayDecoder dec = _decoderFactory().getLongArrayDecoder();
- _getAttributeAsArray(dec, getAttributeValue(index));
- return dec.getValues();
- }
-
- public float[] getAttributeAsFloatArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.FloatArrayDecoder dec = _decoderFactory().getFloatArrayDecoder();
- _getAttributeAsArray(dec, getAttributeValue(index));
- return dec.getValues();
- }
-
- public double[] getAttributeAsDoubleArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DoubleArrayDecoder dec = _decoderFactory().getDoubleArrayDecoder();
- _getAttributeAsArray(dec, getAttributeValue(index));
- return dec.getValues();
- }
-
- public int getAttributeAsArray(int index, TypedArrayDecoder tad) throws XMLStreamException
- {
- return _getAttributeAsArray(tad, getAttributeValue(index));
- }
-
- protected int _getAttributeAsArray(TypedArrayDecoder tad, String attrValue) throws XMLStreamException
- {
- int ptr = 0;
- int start = 0;
- final int end = attrValue.length();
- String lexical = null;
- int count = 0;
-
- try {
- decode_loop:
- while (ptr < end) {
- // First, any space to skip?
- while (attrValue.charAt(ptr) <= INT_SPACE) {
- if (++ptr >= end) {
- break decode_loop;
- }
- }
- // Then let's figure out non-space char (token)
- start = ptr;
- ++ptr;
- while (ptr < end && attrValue.charAt(ptr) > INT_SPACE) {
- ++ptr;
- }
- int tokenEnd = ptr;
- ++ptr; // to skip trailing space (or, beyond end)
- // And there we have it
- lexical = attrValue.substring(start, tokenEnd);
- ++count;
- if (tad.decodeValue(lexical)) {
- if (!checkExpand(tad)) {
- break;
- }
- }
- }
- } catch (IllegalArgumentException iae) {
- // Need to convert to a checked stream exception
- Location loc = getLocation();
- throw new TypedXMLStreamException(lexical, iae.getMessage(), loc, iae);
- }
- return count;
- }
-
- /**
- * Internal method used to see if we can expand the buffer that
- * the array decoder has. Bit messy, but simpler than having
- * separately typed instances; and called rarely so that performance
- * downside of instanceof is irrelevant.
- */
- private final boolean checkExpand(TypedArrayDecoder tad)
- {
- if (tad instanceof ValueDecoderFactory.BaseArrayDecoder) {
- ((ValueDecoderFactory.BaseArrayDecoder) tad).expand();
- return true;
- }
- return false;
- }
-
- public byte[] getAttributeAsBinary(int index) throws XMLStreamException
- {
- return getAttributeAsBinary(index, Base64Variants.getDefaultVariant());
- }
-
- public byte[] getAttributeAsBinary(int index, Base64Variant v) throws XMLStreamException
- {
- String lexical = getAttributeValue(index);
- final StringBase64Decoder dec = _base64Decoder();
- dec.init(v, true, lexical);
- try {
- return dec.decodeCompletely();
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, lexical);
- }
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamReader2 (StAX2) implementation
- ////////////////////////////////////////////////////
- */
-
- // // // StAX2, per-reader configuration
-
- public Object getFeature(String name)
- {
- // No readable features supported yet
- throw new IllegalArgumentException("Unrecognized feature \""+name+"\"");
- }
-
- public void setFeature(String name, Object value)
- {
- throw new IllegalArgumentException("Unrecognized feature \""+name+"\"");
- }
-
- // // // StAX2, additional traversal methods
-
- public void skipElement() throws XMLStreamException
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- int nesting = 1; // need one more end elements than start elements
-
- while (true) {
- int type = next();
- if (type == START_ELEMENT) {
- ++nesting;
- } else if (type == END_ELEMENT) {
- if (--nesting == 0) {
- break;
- }
- }
- }
- }
-
- // // // StAX2, additional attribute access
-
- public AttributeInfo getAttributeInfo() throws XMLStreamException
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- return this;
- }
-
- // AttributeInfo impl:
-
- //public int getAttributeCount()
-
- public int findAttributeIndex(String nsURI, String localName)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- Element elem = (Element) _currNode;
- NamedNodeMap attrs = elem.getAttributes();
- if (nsURI != null && nsURI.length() == 0) {
- nsURI = null;
- }
- // Ugh. Horrible clumsy code. But has to do...
- for (int i = 0, len = attrs.getLength(); i < len; ++i) {
- Node attr = attrs.item(i);
- String ln = _safeGetLocalName(attr);
- if (localName.equals(ln)) {
- String thisUri = attr.getNamespaceURI();
- boolean isEmpty = (thisUri == null) || thisUri.length() == 0;
- if (nsURI == null) {
- if (isEmpty) {
- return i;
- }
- } else {
- if (!isEmpty && nsURI.equals(thisUri)) {
- return i;
- }
- }
- }
- }
- return -1;
- }
-
- public int getIdAttributeIndex()
- {
- // !!! TBI
-
- // Note: will need Dom3 level support (JDK 1.5)
-
- return -1;
- }
-
- public int getNotationAttributeIndex()
- {
- // !!! TBI
-
- // Note: will need Dom3 level support (JDK 1.5)
-
- return -1;
- }
-
- // // // StAX2, Additional DTD access
-
- /**
- * Since this class implements {@link DTDInfo}, method can just
- * return
- * TODO: try to optimize to allow completely streaming pass-through:
- * currently will still read all data in memory buffers before
- * outputting
- *
- * @param w Writer to use for writing textual contents
- * @param preserveContents If true, reader has to preserve contents
- * so that further calls to
- * Note that the implementation is only to be used with
- *
- * Note: the implementation may be incomplete as-is, since not all
- * features needed are necessarily accessible via basic Stax 1.0 interface.
- * As such, two main use cases for this wrapper are:
- *
- * Some notes about implemention:
- *
- * Since there is not much to optimize at this
- * level (API and underlying stream reader pretty much define functionality
- * and optimizations that can be done), implementation is fairly straight
- * forward, with not many surprises.
- *
- * Implementation notes: the trickiest things to implement are:
- *
- * Note: although the interface allows implementations to
- * throw an {@link XMLStreamException}, the reference implementation
- * doesn't currently need to.
- * It's still declared, in case in future there is need to throw
- * such an exception.
- */
- public boolean hasNextEvent()
- throws XMLStreamException
- {
- return (mState != STATE_END_OF_INPUT);
- }
-
- /*
- ///////////////////////////////////////////////
- // Overridable factory methods
- ///////////////////////////////////////////////
- */
-
- protected XMLEvent createNextEvent(boolean checkEOD, int type)
- throws XMLStreamException
- {
- try {
- XMLEvent evt = mAllocator.allocate(mReader);
- if (checkEOD && type == END_DOCUMENT) {
- mState = STATE_END_OF_INPUT;
- }
- return evt;
- } catch (RuntimeException rex) {
- /* 29-Mar-2008, TSa: Due to some problems with Stax API
- * (lack of 'throws XMLStreamException' in signature of
- * XMLStreamReader.getText(), for one) it is possible
- * we will get a wrapped XMLStreamException. If so,
- * we should be able to unwrap it.
- */
- Throwable t = rex.getCause();
- while (t != null) {
- if (t instanceof XMLStreamException) {
- throw (XMLStreamException) t;
- }
- t = t.getCause();
- }
- // Nope, need to re-throw as is
- throw rex;
- }
- }
-
- /**
- * Method called to create the very first event (START_DOCUMENT).
- */
- protected XMLEvent createStartDocumentEvent()
- throws XMLStreamException
- {
- XMLEvent start = mAllocator.allocate(mReader);
- return start;
- }
-
- /*
- ///////////////////////////////////////////////
- // Overridable error reporting methods
- ///////////////////////////////////////////////
- */
-
- private void throwEndOfInput()
- {
- throw new NoSuchElementException();
- }
-
- protected void throwUnchecked(XMLStreamException sex)
- {
- /* Wrapped root cause? Let's only unwrap one layer; one that
- * must have been used to expose the problem (if any)
- */
- Throwable t = (sex.getNestedException() == null) ? sex : sex.getNestedException();
- // Unchecked? Can re-throw as is
- if (t instanceof RuntimeException) {
- throw (RuntimeException) t;
- }
- if (t instanceof Error) {
- throw (Error) t;
- }
- // Otherwise, let's just wrap it
- throw new RuntimeException("[was "+t.getClass()+"] "+t.getMessage(), t);
- }
-
- protected void reportProblem(String msg)
- throws XMLStreamException
- {
- reportProblem(msg, mReader.getLocation());
- }
-
- protected void reportProblem(String msg, Location loc)
- throws XMLStreamException
- {
- if (loc == null) {
- throw new XMLStreamException(msg);
- }
- throw new XMLStreamException(msg, loc);
- }
-
- /*
- ///////////////////////////////////////////////
- // Package methods for sub-classes
- ///////////////////////////////////////////////
- */
-
- protected XMLStreamReader getStreamReader()
- {
- return mReader;
- }
-
- /*
- ///////////////////////////////////////////////
- // Other internal methods
- ///////////////////////////////////////////////
- */
-
- /**
- * Method used to locate error message description to use.
- * Calls sub-classes
- * Note: ALL events (except for custom ones ref. impl. itself doesn't
- * produce, and thus may not always be able to deal with) are routed
- * through stream writer. This because it may want to do
- * different kinds of validation
- */
- public void add(XMLEvent event)
- throws XMLStreamException
- {
- switch (event.getEventType()) {
- /* First events that we have to route via stream writer, to
- * get and/or update namespace information:
- */
-
- case ATTRIBUTE: // need to pass to stream writer, to get namespace info
- {
- Attribute attr = (Attribute) event;
- QName name = attr.getName();
- mWriter.writeAttribute(name.getPrefix(), name.getNamespaceURI(),
- name.getLocalPart(), attr.getValue());
- }
- break;
-
- case END_DOCUMENT:
- mWriter.writeEndDocument();
- break;
-
- case END_ELEMENT:
- mWriter.writeEndElement();
- break;
-
- case NAMESPACE:
- {
- Namespace ns = (Namespace) event;
- mWriter.writeNamespace(ns.getPrefix(), ns.getNamespaceURI());
- }
- break;
-
- case START_DOCUMENT:
- {
- StartDocument sd = (StartDocument) event;
- if (!sd.encodingSet()) { // encoding defined?
- mWriter.writeStartDocument(sd.getVersion());
- } else {
- mWriter.writeStartDocument(sd.getCharacterEncodingScheme(),
- sd.getVersion());
- }
- }
- break;
-
- case START_ELEMENT:
-
- {
- StartElement se = event.asStartElement();
- QName n = se.getName();
- mWriter.writeStartElement(n.getPrefix(), n.getLocalPart(),
- n.getNamespaceURI());
- Iterator it = se.getNamespaces();
- while (it.hasNext()) {
- Namespace ns = (Namespace) it.next();
- add(ns);
- }
- it = se.getAttributes();
- while (it.hasNext()) {
- Attribute attr = (Attribute) it.next();
- add(attr);
- }
- }
- break;
-
- /* Then events we could output directly if necessary... but that
- * make sense to route via stream writer, for validation
- * purposes.
- */
-
- case CHARACTERS: // better pass to stream writer, for prolog/epilog validation
- {
- Characters ch = event.asCharacters();
- String text = ch.getData();
- if (ch.isCData()) {
- mWriter.writeCData(text);
- } else {
- mWriter.writeCharacters(text);
- }
- }
- break;
-
- case CDATA:
- mWriter.writeCData(event.asCharacters().getData());
- break;
-
- case COMMENT:
- mWriter.writeComment(((Comment) event).getText());
- break;
-
- case DTD:
- mWriter.writeDTD(((DTD) event).getDocumentTypeDeclaration());
- break;
-
- case ENTITY_REFERENCE:
- mWriter.writeEntityRef(((EntityReference) event).getName());
- break;
-
- case PROCESSING_INSTRUCTION: // let's just write directly
- {
- ProcessingInstruction pi = (ProcessingInstruction) event;
- mWriter.writeProcessingInstruction(pi.getTarget(), pi.getData());
- }
- break;
-
- case ENTITY_DECLARATION: // not yet produced by Wstx
- case NOTATION_DECLARATION: // not yet produced by Wstx
- case SPACE: // usually only CHARACTERS events exist...
- default:
-
- // Easy, if stax2 enabled
- if (event instanceof XMLEvent2) {
- ((XMLEvent2) event).writeUsing(mWriter);
- } else {
- // Otherwise... well, no real way to do it in generic manner
- throw new XMLStreamException("Don't know how to output event "+event);
- }
- }
- }
-
- public void add(XMLEventReader reader)
- throws XMLStreamException
- {
- while (reader.hasNext()) {
- add(reader.nextEvent());
- }
- }
-
- public void close()
- throws XMLStreamException
- {
- mWriter.close();
- }
-
- public void flush()
- throws XMLStreamException
- {
- mWriter.flush();
- }
-
- public NamespaceContext getNamespaceContext() {
- return mWriter.getNamespaceContext();
- }
-
- public String getPrefix(String uri)
- throws XMLStreamException
- {
- return mWriter.getPrefix(uri);
- }
-
- public void setDefaultNamespace(String uri)
- throws XMLStreamException
- {
- mWriter.setDefaultNamespace(uri);
- }
-
- public void setNamespaceContext(NamespaceContext ctxt)
- throws XMLStreamException
- {
- mWriter.setNamespaceContext(ctxt);
- }
-
- public void setPrefix(String prefix, String uri)
- throws XMLStreamException
- {
- mWriter.setPrefix(prefix, uri);
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2FilteredStreamReader.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2FilteredStreamReader.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2FilteredStreamReader.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2FilteredStreamReader.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,59 +0,0 @@
-package org.codehaus.stax2.ri;
-
-import javax.xml.stream.*;
-
-import org.codehaus.stax2.*;
-import org.codehaus.stax2.util.StreamReader2Delegate;
-
-/**
- * Simple straight-forward implementation of a filtering stream reader,
- * which can fully adapt Stax2 stream reader
- * ({@link XMLStreamReader2}).
- */
-public class Stax2FilteredStreamReader
- extends StreamReader2Delegate
- implements XMLStreamConstants
-{
- final StreamFilter mFilter;
-
- public Stax2FilteredStreamReader(XMLStreamReader r, StreamFilter f)
- {
- super(Stax2ReaderAdapter.wrapIfNecessary(r));
- mFilter = f;
- }
-
- /*
- //////////////////////////////////////////////////////
- // XMLStreamReader method overrides that we need
- //////////////////////////////////////////////////////
- */
-
- public int next()
- throws XMLStreamException
- {
- int type;
- do {
- type = mDelegate2.next();
- if (mFilter.accept(this)) {
- break;
- }
- } while (type != END_DOCUMENT);
-
- return type;
- }
-
- public int nextTag()
- throws XMLStreamException
- {
- int type;
- // Can be implemented very much like next()
- while (true) {
- type = mDelegate2.nextTag();
- if (mFilter.accept(this)) {
- break;
- }
- }
- return type;
- }
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2LocationAdapter.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2LocationAdapter.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2LocationAdapter.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2LocationAdapter.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,69 +0,0 @@
-package org.codehaus.stax2.ri;
-
-import javax.xml.stream.Location;
-
-import org.codehaus.stax2.XMLStreamLocation2;
-
-/**
- * Simple implementation of {@link XMLStreamLocation2}, which just
- * wraps Stax 1.0 {@link Location} and adds no-operation implementation
- * of the additions.
- */
-public class Stax2LocationAdapter
- implements XMLStreamLocation2
-{
- protected final Location mWrappedLocation;
-
- protected final Location mParentLocation;
-
- public Stax2LocationAdapter(Location loc)
- {
- this(loc, null);
- }
-
- public Stax2LocationAdapter(Location loc, Location parent)
- {
- mWrappedLocation = loc;
- mParentLocation = parent;
- }
-
- // // // Basic Stax 1.0 implementation
-
- public int getCharacterOffset()
- {
- return mWrappedLocation.getCharacterOffset();
- }
-
- public int getColumnNumber()
- {
- return mWrappedLocation.getColumnNumber();
- }
-
- public int getLineNumber()
- {
- return mWrappedLocation.getLineNumber();
- }
-
- public String getPublicId()
- {
- return mWrappedLocation.getPublicId();
- }
-
- public String getSystemId()
- {
- return mWrappedLocation.getSystemId();
- }
-
- // // // And stax2 additions
-
- public XMLStreamLocation2 getContext()
- {
- if (mParentLocation == null) {
- return null;
- }
- if (mParentLocation instanceof XMLStreamLocation2) {
- return (XMLStreamLocation2) mParentLocation;
- }
- return new Stax2LocationAdapter(mParentLocation);
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2ReaderAdapter.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2ReaderAdapter.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2ReaderAdapter.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2ReaderAdapter.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,1065 +0,0 @@
-package org.codehaus.stax2.ri;
-
-import java.io.IOException;
-import java.io.Writer;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-import javax.xml.stream.util.StreamReaderDelegate;
-
-import org.codehaus.stax2.typed.Base64Variant;
-import org.codehaus.stax2.typed.Base64Variants;
-import org.codehaus.stax2.typed.TypedArrayDecoder;
-import org.codehaus.stax2.typed.TypedValueDecoder;
-import org.codehaus.stax2.typed.TypedXMLStreamException;
-import org.codehaus.stax2.ri.Stax2Util;
-import org.codehaus.stax2.ri.typed.StringBase64Decoder;
-import org.codehaus.stax2.ri.typed.ValueDecoderFactory;
-
-import org.codehaus.stax2.*;
-import org.codehaus.stax2.validation.*;
-
-/**
- * This adapter implements parts of {@link XMLStreamReader2}, the
- * extended stream reader defined by Stax2 extension, by wrapping
- * a vanilla Stax 1.0 {@link XMLStreamReader} implementation.
- *
- * Note: the implementation is incomplete as-is, since not all
- * features needed are accessible via basic Stax 1.0 interface.
- * As such, two main use cases for this wrapper are:
- *
- * !!! TODO: should be possible to implement completely
- */
- public abstract int readElementAsArray(TypedArrayDecoder dec)
- throws XMLStreamException;
-
- /*
- ////////////////////////////////////////////////////////
- // TypedXMLStreamReader2 implementation, binary data
- ////////////////////////////////////////////////////////
- */
-
- public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength)
- throws XMLStreamException
- {
- return readElementAsBinary(Base64Variants.getDefaultVariant(), resultBuffer, offset, maxLength);
- }
-
- public abstract int readElementAsBinary(Base64Variant b64variant, byte[] resultBuffer, int offset, int maxLength)
- throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // TypedXMLStreamReader2 implementation, scalar attributes
- ///////////////////////////////////////////////////////////
- */
-
- public abstract int getAttributeIndex(String namespaceURI, String localName);
-
- public boolean getAttributeAsBoolean(int index) throws XMLStreamException
- {
- ValueDecoderFactory.BooleanDecoder dec = _decoderFactory().getBooleanDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public int getAttributeAsInt(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntDecoder dec = _decoderFactory().getIntDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public long getAttributeAsLong(int index) throws XMLStreamException
- {
- ValueDecoderFactory.LongDecoder dec = _decoderFactory().getLongDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public float getAttributeAsFloat(int index) throws XMLStreamException
- {
- ValueDecoderFactory.FloatDecoder dec = _decoderFactory().getFloatDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public double getAttributeAsDouble(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DoubleDecoder dec = _decoderFactory().getDoubleDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public BigInteger getAttributeAsInteger(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntegerDecoder dec = _decoderFactory().getIntegerDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public BigDecimal getAttributeAsDecimal(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DecimalDecoder dec = _decoderFactory().getDecimalDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public QName getAttributeAsQName(int index) throws XMLStreamException
- {
- ValueDecoderFactory.QNameDecoder dec = _decoderFactory().getQNameDecoder(getNamespaceContext());
- getAttributeAs(index, dec);
- // !!! Should we try to verify validity of name chars?
- return dec.getValue();
- }
-
- public void getAttributeAs(int index, TypedValueDecoder tvd) throws XMLStreamException
- {
- String value = getAttributeValue(index);
- try {
- tvd.decode(value);
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, value);
- }
- }
-
- public int[] getAttributeAsIntArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntArrayDecoder dec = _decoderFactory().getIntArrayDecoder();
- getAttributeAsArray(index, dec);
- return dec.getValues();
- }
-
- public long[] getAttributeAsLongArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.LongArrayDecoder dec = _decoderFactory().getLongArrayDecoder();
- getAttributeAsArray(index, dec);
- return dec.getValues();
- }
-
- public float[] getAttributeAsFloatArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.FloatArrayDecoder dec = _decoderFactory().getFloatArrayDecoder();
- getAttributeAsArray(index, dec);
- return dec.getValues();
- }
-
- public double[] getAttributeAsDoubleArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DoubleArrayDecoder dec = _decoderFactory().getDoubleArrayDecoder();
- getAttributeAsArray(index, dec);
- return dec.getValues();
- }
-
- /**
- * Actual implementation needs to implement tokenization.
- *
- * !!! TODO: should be possible to implement completely
- */
- public abstract int getAttributeAsArray(int index, TypedArrayDecoder tad) throws XMLStreamException;
-
- public byte[] getAttributeAsBinary(int index) throws XMLStreamException
- {
- return getAttributeAsBinary(Base64Variants.getDefaultVariant(), index);
- }
-
- public abstract byte[] getAttributeAsBinary(Base64Variant v, int index) throws XMLStreamException;
-
- /*
- ////////////////////////////////////////////////////
- // Package methods
- ////////////////////////////////////////////////////
- */
-
- protected ValueDecoderFactory _decoderFactory()
- {
- if (_decoderFactory == null) {
- _decoderFactory = new ValueDecoderFactory();
- }
- return _decoderFactory;
- }
-
- protected TypedXMLStreamException _constructTypeException(IllegalArgumentException iae, String lexicalValue)
- {
- return new TypedXMLStreamException(lexicalValue, iae.getMessage(), getStartLocation(), iae);
- }
-
- /*
- ////////////////////////////////////////////////////
- // Internal methods
- ////////////////////////////////////////////////////
- */
-
- protected void throwUnsupported()
- throws XMLStreamException
- {
- throw new XMLStreamException("Unsupported method");
- }
-
- protected void throwNotStartElem()
- {
- throw new IllegalStateException("Current state not START_ELEMENT");
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2Util.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2Util.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2Util.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2Util.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,279 +0,0 @@
-/* Stax2 API extension for Streaming Api for Xml processing (StAX).
- *
- * Copyright (c) 2006- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in the file LICENSE which is
- * included with the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri;
-
-import javax.xml.stream.XMLStreamConstants;
-
-public final class Stax2Util
- implements XMLStreamConstants
-{
- private Stax2Util() { } // no instantiation
-
- /**
- * Method that converts given standard Stax event type into
- * textual representation.
- */
- public static String eventTypeDesc(int type)
- {
- switch (type) {
- case START_ELEMENT:
- return "START_ELEMENT";
- case END_ELEMENT:
- return "END_ELEMENT";
- case START_DOCUMENT:
- return "START_DOCUMENT";
- case END_DOCUMENT:
- return "END_DOCUMENT";
-
- case CHARACTERS:
- return "CHARACTERS";
- case CDATA:
- return "CDATA";
- case SPACE:
- return "SPACE";
-
- case COMMENT:
- return "COMMENT";
- case PROCESSING_INSTRUCTION:
- return "PROCESSING_INSTRUCTION";
- case DTD:
- return "DTD";
- case ENTITY_REFERENCE:
- return "ENTITY_REFERENCE";
- }
- return "["+type+"]";
- }
- /**
- * Method called to trim leading and/or trailing space that given
- * lexical value has.
- *
- * @return Trimmed value if
- * Note that it is assumed that any "weird" white space
- * (xml 1.1 LSEP and NEL) have been replaced by canonical
- * alternatives (linefeed for element content, regular space
- * for attributes)
- */
- private final static boolean _isSpace(char c)
- {
- return ((int) c) <= 0x0020;
- }
-
- /**
- * Helper class used to simplify text gathering while keeping
- * at as efficient as possible.
- */
- public final static class TextBuffer
- {
- private String mText = null;
-
- /* !!! JDK 1.5: when we can upgrade to Java 5, can convert
- * to using
- * Note: the implementation is incomplete as-is, since not all
- * features needed are accessible via basic Stax 1.0 interface.
- * As such, two main use cases for this wrapper are:
- *
- * General contract for encoding is that caller must call things
- * in following sequence:
- *
- * Main restrictions for use are that value serializations must
- * produce only 7-bit ascii characters, and that the value can
- * be produced incrementally using limited size buffers. This
- * is true for all current value types of the Typed Access API.
- *
- * Finally, details of how encoders are created and/or reused
- * is outside scope of this public interface. Stax2 reference
- * implementation handles this using an encoder factory
- * that knows construction details.
- *
- * @since 3.0
- */
-public abstract class AsciiValueEncoder
-{
- /**
- * Constant used to determine when caller should flush buffer
- * before calling encode methods. Strict minimum would be
- * something like 22 (for floating point numbers), but let's
- * pad it a bit.
- */
- protected final static int MIN_CHARS_WITHOUT_FLUSH = 64;
-
- protected AsciiValueEncoder() { }
-
- /**
- * Method called by writer to check if it should flush its
- * output buffer (which has specified amount of free space)
- * before encoder can encode more data. Flushing is only
- * needed if (a) encoder has more data to output, and
- * (b) free space is not enough to contain smallest
- * segment of encoded value (individual array element
- * or encoded primitive value).
- *
- * @param freeChars Amount of free space (in characters) in
- * the output buffer
- *
- * @return True if encoder still has data to output and
- * specified amount of free space is insufficient for
- * encoding any more data
- */
- public final boolean bufferNeedsFlush(int freeChars)
- {
- /* 25-Jun-2008, tatu: Although minimum ok sizes differ,
- * let's simplify this a bit and use uniform threshold:
- * it just needs to ensure that it's higher than any
- * individual minimum would be. It may lead to more
- * flushes, but overall shouldn't matter a whole lot.
- * But removes need for sub-classes to implement it
- */
- return (freeChars < MIN_CHARS_WITHOUT_FLUSH);
- }
-
- /**
- * Method that can alternatively be called to determine whether encoder
- * has encoded all data it has. Generally called right after
- * a call to {@link #encodeMore}, to figure out whether buffer flush
- * is needed (there is more data), or encoding is complete.
- */
- public abstract boolean isCompleted();
-
- /**
- * @return Value of pointer after all remaining data (which
- * may be "none") that can be encoded (as constrained by
- * buffer length) has been encoded. Has to exceed 'ptr'
- * value sent in; will be equal to it if nothing was
- * encoded (which should only occur when everything has
- * been encoded, as long as {@link #bufferNeedsFlush}
- * is appropriately called once before calling this
- * method)
- */
- public abstract int encodeMore(char[] buffer, int ptr, int end);
-
- /**
- * @return Value of pointer after all remaining data (which
- * may be "none") that can be encoded (as constrained by
- * buffer length) has been encoded. Has to exceed 'ptr'
- * value sent in; will be equal to it if nothing was
- * encoded (which should only occur when everything has
- * been encoded, as long as {@link #bufferNeedsFlush}
- * is appropriately called once before calling this
- * method)
- */
- public abstract int encodeMore(byte[] buffer, int ptr, int end);
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/Base64DecoderBase.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/Base64DecoderBase.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/Base64DecoderBase.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/Base64DecoderBase.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,280 +0,0 @@
-/* StAX2 extension for StAX API (JSR-173).
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.typed;
-
-import org.codehaus.stax2.typed.Base64Variant;
-import org.codehaus.stax2.ri.Stax2Util;
-
-/**
- * Abstract base class used to share functionality between concrete
- * base64 decoders.
- *
- * Mostly what follows is just shared definitions of the state machine
- * states to use, but there is also shared convenience functionality
- * for convenience decoding into simple byte arrays.
- */
-abstract class Base64DecoderBase
-{
- // // // Constants for the simple state machine used for decoding
-
- /**
- * Initial state is where we start, and where white space
- * is accepted.
- */
- final static int STATE_INITIAL = 0;
-
- /**
- * State in which we have gotten one valid non-padding base64 encoded
- * character
- */
- final static int STATE_VALID_1 = 1;
-
- /**
- * State in which we have gotten two valid non-padding base64 encoded
- * characters.
- */
- final static int STATE_VALID_2 = 2;
-
- /**
- * State in which we have gotten three valid non-padding base64 encoded
- * characters.
- */
- final static int STATE_VALID_3 = 3;
-
- /**
- * State in which we have succesfully decoded a full triplet, but not
- * yet output any characters
- */
- final static int STATE_OUTPUT_3 = 4;
-
- /**
- * State in which we have 2 decoded bytes to output (either due to
- * partial triplet, or having output one byte from full triplet).
- */
- final static int STATE_OUTPUT_2 = 5;
-
- /**
- * State in which we have 1 decoded byte to output (either due to
- * partial triplet, or having output some of decoded bytes earlier)
- */
- final static int STATE_OUTPUT_1 = 6;
-
- /**
- * State in which we have gotten two valid non-padding base64 encoded
- * characters, followed by a single padding character. This means
- * that we must get one more padding character to be able to decode
- * the single encoded byte
- */
- final static int STATE_VALID_2_AND_PADDING = 7;
-
- // // // Character constants
-
- final static int INT_SPACE = 0x0020;
-
- // // // Base64 variant info
-
- /**
- * Details of base64 variant (alphabet in use, padding, line length)
- * are contained in and accessed via this object. It is passed
- * through init methods.
- */
- Base64Variant _variant;
-
- // // // Decoding State
-
- /**
- * State of the state machine
- */
- int _state = STATE_INITIAL;
-
- /**
- * Data decoded and/or ready to be output. Alignment and storage format
- * depend on state: during decoding things are appended from lowest
- * significant bits, and during output, flushed from more significant
- * bytes.
- */
- int _decodedData;
-
- // // // Reused state for convenience byte[] accessors
-
- Stax2Util.ByteAggregator _byteAggr = null;
-
- /*
- //////////////////////////////////////////////////////////////
- // Life-cycle
- //////////////////////////////////////////////////////////////
- */
-
- protected Base64DecoderBase() { }
-
- /*
- //////////////////////////////////////////////////////////////
- // Shared base API
- //////////////////////////////////////////////////////////////
- */
-
- /**
- * Method that does actual decoding
- */
- public abstract int decode(byte[] resultBuffer, int resultOffset, int maxLength)
- throws IllegalArgumentException;
-
- /**
- * Method that can be called to check if this decoder is in has unflushed
- * data ready to be returned.
- */
- public final boolean hasData()
- {
- return (_state >= STATE_OUTPUT_3) && (_state <= STATE_OUTPUT_1);
- }
-
- /**
- * Method called to indicate that we have no more encoded content to
- * process, and decoding is to finish. Depending base64 variant in
- * use, this means one of three things:
- *
- * Note: we'll increase value since Integer.MIN_VALUE can not
- * actually be output using simple int-serialization mechanism
- * (since its negation does not fit in 32-bit signed int range)
- */
- private static long MIN_INT_AS_LONG = (long) (Integer.MIN_VALUE+1);
-
- private static long MAX_INT_AS_LONG = (long) Integer.MAX_VALUE;
-
- final static char[] LEADING_TRIPLETS = new char[4000];
- final static char[] FULL_TRIPLETS = new char[4000];
- static {
- /* Let's fill it with NULLs for ignorable leading digits,
- * and digit chars for others
- */
- int ix = 0;
- for (int i1 = 0; i1 < 10; ++i1) {
- char f1 = (char) ('0' + i1);
- char l1 = (i1 == 0) ? NULL_CHAR : f1;
- for (int i2 = 0; i2 < 10; ++i2) {
- char f2 = (char) ('0' + i2);
- char l2 = (i1 == 0 && i2 == 0) ? NULL_CHAR : f2;
- for (int i3 = 0; i3 < 10; ++i3) {
- // Last is never to be empty
- char f3 = (char) ('0' + i3);
- LEADING_TRIPLETS[ix] = l1;
- LEADING_TRIPLETS[ix+1] = l2;
- LEADING_TRIPLETS[ix+2] = f3;
- FULL_TRIPLETS[ix] = f1;
- FULL_TRIPLETS[ix+1] = f2;
- FULL_TRIPLETS[ix+2] = f3;
- ix += 4;
- }
- }
- }
- }
-
- /*
- ///////////////////////////////////////////////////////////////
- // Public API
- ///////////////////////////////////////////////////////////////
- */
-
- /**
- *
- * Note: caller must ensure that there is room for least 11 characters
- * (leading sign, and up to 10 digits) in buffer passed.
- *
- * @return Offset within buffer after outputting int
- */
- public static int writeInt(int value, char[] buffer, int offset)
- {
- if (value < 0) {
- // In general, can just output sign, negate, handle as positives
- if (value == Integer.MIN_VALUE) {
- /* But one special case: no matching positive value within
- * range; let's just output as long
- */
- return writeLong((long) value, buffer, offset);
- }
- buffer[offset++] = '-';
- value = -value;
- }
-
- if (value < MILLION) { // at most 2 triplets...
- if (value < 1000) {
- if (value < 10) {
- buffer[offset++] = (char) ('0' + value);
- } else {
- offset = writeLeadingTriplet(value, buffer, offset);
- }
- } else {
- int thousands = value / 1000;
- value -= (thousands * 1000); // == value % 1000
- offset = writeLeadingTriplet(thousands, buffer, offset);
- offset = writeFullTriplet(value, buffer, offset);
- }
- return offset;
- }
-
- // ok, all 3 triplets included
- /* Let's first hand possible billions separately before
- * handling 3 triplets. This is possible since we know we
- * can have at most '2' as billion count.
- */
- boolean hasBillions = (value >= BILLION);
- if (hasBillions) {
- value -= BILLION;
- if (value >= BILLION) {
- value -= BILLION;
- buffer[offset++] = '2';
- } else {
- buffer[offset++] = '1';
- }
- }
- int newValue = value / 1000;
- int ones = (value - (newValue * 1000)); // == value % 1000
- value = newValue;
- newValue /= 1000;
- int thousands = (value - (newValue * 1000));
-
- // value now has millions, which have 1, 2 or 3 digits
- if (hasBillions) {
- offset = writeFullTriplet(newValue, buffer, offset);
- } else {
- offset = writeLeadingTriplet(newValue, buffer, offset);
- }
- offset = writeFullTriplet(thousands, buffer, offset);
- offset = writeFullTriplet(ones, buffer, offset);
- return offset;
- }
-
- // Cut'n pasted from above
- public static int writeInt(int value, byte[] buffer, int offset)
- {
- if (value < 0) {
- if (value == Integer.MIN_VALUE) {
- return writeLong((long) value, buffer, offset);
- }
- buffer[offset++] = BYTE_HYPHEN;
- value = -value;
- }
- if (value < MILLION) {
- if (value < 1000) {
- if (value < 10) {
- buffer[offset++] = (byte) ('0' + value);
- } else {
- offset = writeLeadingTriplet(value, buffer, offset);
- }
- } else {
- int thousands = value / 1000;
- value -= (thousands * 1000); // == value % 1000
- offset = writeLeadingTriplet(thousands, buffer, offset);
- offset = writeFullTriplet(value, buffer, offset);
- }
- return offset;
- }
- boolean hasBillions = (value >= BILLION);
- if (hasBillions) {
- value -= BILLION;
- if (value >= BILLION) {
- value -= BILLION;
- buffer[offset++] = BYTE_2;
- } else {
- buffer[offset++] = BYTE_1;
- }
- }
- int newValue = value / 1000;
- int ones = (value - (newValue * 1000)); // == value % 1000
- value = newValue;
- newValue /= 1000;
- int thousands = (value - (newValue * 1000));
-
- // value now has millions, which have 1, 2 or 3 digits
- if (hasBillions) {
- offset = writeFullTriplet(newValue, buffer, offset);
- } else {
- offset = writeLeadingTriplet(newValue, buffer, offset);
- }
- offset = writeFullTriplet(thousands, buffer, offset);
- offset = writeFullTriplet(ones, buffer, offset);
- return offset;
- }
-
- /**
- *
- * Note: caller must ensure that there is room for least 21 characters
- * (leading sign, and up to 20 digits ) in buffer passed.
- *
- * @return Offset within buffer after outputting int
- */
- public static int writeLong(long value, char[] buffer, int offset)
- {
- // First: does it actually fit in an int?
- if (value < 0L) {
- if (value >= MIN_INT_AS_LONG) {
- return writeInt((int) value, buffer, offset);
- }
- if (value == Long.MIN_VALUE) {
- // Special case: no matching positive value within range
- return getChars(String.valueOf(value), buffer, offset);
- }
- buffer[offset++] = '-';
- value = -value;
- } else {
- if (value <= MAX_INT_AS_LONG) {
- return writeInt((int) value, buffer, offset);
- }
- }
-
- /* Ok: real long print. Need to first figure out length
- * in characters, and then print in from end to beginning
- */
- int origOffset = offset;
- offset += calcLongStrLength(value);
- int ptr = offset;
-
- // First, with long arithmetics:
- while (value > MAX_INT_AS_LONG) { // full triplet
- ptr -= 3;
- long newValue = value / THOUSAND_L;
- int triplet = (int) (value - newValue * THOUSAND_L);
- writeFullTriplet(triplet, buffer, ptr);
- value = newValue;
- }
- // Then with int arithmetics:
- int ivalue = (int) value;
- while (ivalue >= 1000) { // still full triplet
- ptr -= 3;
- int newValue = ivalue / 1000;
- int triplet = ivalue - (newValue * 1000);
- writeFullTriplet(triplet, buffer, ptr);
- ivalue = newValue;
- }
- // And finally, if anything remains, partial triplet
- writeLeadingTriplet(ivalue, buffer, origOffset);
-
- return offset;
- }
-
- // Cut'n pasted from above
- public static int writeLong(long value, byte[] buffer, int offset)
- {
- if (value < 0L) {
- if (value >= MIN_INT_AS_LONG) {
- return writeInt((int) value, buffer, offset);
- }
- if (value == Long.MIN_VALUE) { // shouldn't be common...
- return getAsciiBytes(String.valueOf(value), buffer, offset);
- }
- buffer[offset++] = BYTE_HYPHEN;
- value = -value;
- } else {
- if (value <= MAX_INT_AS_LONG) {
- return writeInt((int) value, buffer, offset);
- }
- }
- int origOffset = offset;
- offset += calcLongStrLength(value);
- int ptr = offset;
-
- while (value > MAX_INT_AS_LONG) { // full triplet
- ptr -= 3;
- long newValue = value / THOUSAND_L;
- int triplet = (int) (value - newValue * THOUSAND_L);
- writeFullTriplet(triplet, buffer, ptr);
- value = newValue;
- }
- int ivalue = (int) value;
- while (ivalue >= 1000) { // still full triplet
- ptr -= 3;
- int newValue = ivalue / 1000;
- int triplet = ivalue - (newValue * 1000);
- writeFullTriplet(triplet, buffer, ptr);
- ivalue = newValue;
- }
- writeLeadingTriplet(ivalue, buffer, origOffset);
- return offset;
- }
-
- public static int writeFloat(float value, char[] buffer, int offset)
- {
- // No real efficient method exposed by JDK, so let's keep it simple
- return getChars(String.valueOf(value), buffer, offset);
- }
-
- public static int writeFloat(float value, byte[] buffer, int offset)
- {
- // No real efficient method exposed by JDK, so let's keep it simple
- return getAsciiBytes(String.valueOf(value), buffer, offset);
- }
-
- public static int writeDouble(double value, char[] buffer, int offset)
- {
- // No real efficient method exposed by JDK, so let's keep it simple
- return getChars(String.valueOf(value), buffer, offset);
- }
-
- public static int writeDouble(double value, byte[] buffer, int offset)
- {
- return getAsciiBytes(String.valueOf(value), buffer, offset);
- }
-
- /*
- ////////////////////////////////////////
- // Internal methods
- ////////////////////////////////////////
- */
-
- private static int writeLeadingTriplet(int triplet, char[] buffer, int offset)
- {
- int digitOffset = (triplet << 2);
- char c = LEADING_TRIPLETS[digitOffset++];
- if (c != NULL_CHAR) {
- buffer[offset++] = c;
- }
- c = LEADING_TRIPLETS[digitOffset++];
- if (c != NULL_CHAR) {
- buffer[offset++] = c;
- }
- // Last is required to be non-empty
- buffer[offset++] = LEADING_TRIPLETS[digitOffset];
- return offset;
- }
-
- private static int writeLeadingTriplet(int triplet, byte[] buffer, int offset)
- {
- int digitOffset = (triplet << 2);
- char c = LEADING_TRIPLETS[digitOffset++];
- if (c != NULL_CHAR) {
- buffer[offset++] = (byte) c;
- }
- c = LEADING_TRIPLETS[digitOffset++];
- if (c != NULL_CHAR) {
- buffer[offset++] = (byte) c;
- }
- // Last is required to be non-empty
- buffer[offset++] = (byte) LEADING_TRIPLETS[digitOffset];
- return offset;
- }
-
- private static int writeFullTriplet(int triplet, char[] buffer, int offset)
- {
- int digitOffset = (triplet << 2);
- buffer[offset++] = FULL_TRIPLETS[digitOffset++];
- buffer[offset++] = FULL_TRIPLETS[digitOffset++];
- buffer[offset++] = FULL_TRIPLETS[digitOffset];
- return offset;
- }
-
- private static int writeFullTriplet(int triplet, byte[] buffer, int offset)
- {
- int digitOffset = (triplet << 2);
- buffer[offset++] = (byte)FULL_TRIPLETS[digitOffset++];
- buffer[offset++] = (byte)FULL_TRIPLETS[digitOffset++];
- buffer[offset++] = (byte)FULL_TRIPLETS[digitOffset];
- return offset;
- }
-
- /**
- *
- * Pre-conditions: posValue is positive, and larger than
- * Integer.MAX_VALUE (about 2 billions).
- */
- private static int calcLongStrLength(long posValue)
- {
- int len = 10;
- long comp = TEN_BILLION_L;
-
- // 19 is longest, need to worry about overflow
- while (posValue >= comp) {
- if (len == 19) {
- break;
- }
- ++len;
- comp = (comp << 3) + (comp << 1); // 10x
- }
- return len;
- }
-
- private static int getChars(String str, char[] buffer, int ptr)
- {
- int len = str.length();
- str.getChars(0, len, buffer, ptr);
- return ptr+len;
- }
-
- private static int getAsciiBytes(String str, byte[] buffer, int ptr)
- {
- for (int i = 0, len = str.length(); i < len; ++i) {
- buffer[ptr++] = (byte) str.charAt(i);
- }
- return ptr;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/SimpleValueEncoder.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/SimpleValueEncoder.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/SimpleValueEncoder.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/SimpleValueEncoder.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,73 +0,0 @@
-package org.codehaus.stax2.ri.typed;
-
-import org.codehaus.stax2.typed.Base64Variant;
-
-/**
- * Helper class used for serializing typed values to String. Mostly
- * used for "non-native" stream writers; things like DOM-backed
- * stream writer, or stax (v1) adapter.
- *
- * @author Tatu Saloranta
- */
-public class SimpleValueEncoder
-{
- /**
- * For efficient encoding, need a working buffer
- */
- protected final char[] mBuffer = new char[500];
-
- protected final ValueEncoderFactory mEncoderFactory;
-
- public SimpleValueEncoder()
- {
- mEncoderFactory = new ValueEncoderFactory();
- }
-
- public String encodeAsString(int[] value, int from, int length)
- {
- return encode(mEncoderFactory.getEncoder(value, from, length));
- }
-
- public String encodeAsString(long[] value, int from, int length)
- {
- return encode(mEncoderFactory.getEncoder(value, from, length));
- }
-
- public String encodeAsString(float[] value, int from, int length)
- {
- return encode(mEncoderFactory.getEncoder(value, from, length));
- }
-
- public String encodeAsString(double[] value, int from, int length)
- {
- return encode(mEncoderFactory.getEncoder(value, from, length));
- }
-
- public String encodeAsString(Base64Variant v, byte[] value, int from, int length)
- {
- return encode(mEncoderFactory.getEncoder(v, value, from, length));
- }
-
- /*
- ///////////////////////////////////////////////////
- // Internal methods
- ///////////////////////////////////////////////////
- */
-
- protected String encode(AsciiValueEncoder enc)
- {
- // note: nothing in buffer, can't flush (thus no need to call to check)
- int last = enc.encodeMore(mBuffer, 0, mBuffer.length);
- if (enc.isCompleted()) { // fitted in completely?
- return new String(mBuffer, 0, last);
- }
- // !!! TODO: with Java 5, use StringBuilder instead
- StringBuffer sb = new StringBuffer(mBuffer.length << 1);
- sb.append(mBuffer, 0, last);
- do {
- last = enc.encodeMore(mBuffer, 0, mBuffer.length);
- sb.append(mBuffer, 0, last);
- } while (!enc.isCompleted());
- return sb.toString();
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/StringBase64Decoder.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/StringBase64Decoder.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/StringBase64Decoder.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/StringBase64Decoder.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,200 +0,0 @@
-/* StAX2 extension for StAX API (JSR-173).
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.typed;
-
-import org.codehaus.stax2.typed.Base64Variant;
-
-/**
- * Base64 decoder that can be used to decode base64 encoded content that
- * is passed as a Single string.
- */
-public final class StringBase64Decoder
- extends Base64DecoderBase
-{
- // // // Input buffer information
-
- /**
- * Base64 content String being currently processed.
- */
- String _currSegment;
-
- int _currSegmentPtr;
-
- int _currSegmentEnd;
-
- public StringBase64Decoder() { super(); }
-
- public void init(Base64Variant variant, boolean firstChunk, String segment)
- {
- _variant = variant;
- if (firstChunk) {
- _state = STATE_INITIAL;
- }
- _currSegment = segment;
- _currSegmentPtr = 0;
- _currSegmentEnd = segment.length();
- }
-
- /**
- * @param resultBuffer Buffer in which decoded bytes are returned
- * @param resultOffset Offset that points to position to put the
- * first decoded byte in maxLength Maximum number of bytes that can be returned
- * in given buffer
- *
- * @return Number of bytes decoded and returned in the result buffer
- */
- public int decode(byte[] resultBuffer, int resultOffset, int maxLength)
- throws IllegalArgumentException
- {
- final int origResultOffset = resultOffset;
- final int resultBufferEnd = resultOffset + maxLength;
-
- main_loop:
- while (true) {
- switch (_state) {
- case STATE_INITIAL:
- // first, we'll skip preceding white space, if any
- {
- char ch;
- do {
- if (_currSegmentPtr >= _currSegmentEnd) {
- break main_loop;
- }
- ch = _currSegment.charAt(_currSegmentPtr++);
- } while (ch <= INT_SPACE);
- int bits = _variant.decodeBase64Char(ch);
- if (bits < 0) {
- throw reportInvalidChar(ch, 0);
- }
- _decodedData = bits;
- }
- // fall through, "fast" path
-
- case STATE_VALID_1:
- // then second base64 char; can't get padding yet, nor ws
- {
- if (_currSegmentPtr >= _currSegmentEnd) {
- _state = STATE_VALID_1; // to cover fall-through case
- break main_loop;
- }
- char ch = _currSegment.charAt(_currSegmentPtr++);
- int bits = _variant.decodeBase64Char(ch);
- if (bits < 0) {
- throw reportInvalidChar(ch, 1);
- }
- _decodedData = (_decodedData << 6) | bits;
- }
- // fall through, "fast path"
-
- case STATE_VALID_2:
- // third base64 char; can be padding, but not ws
- {
- if (_currSegmentPtr >= _currSegmentEnd) {
- _state = STATE_VALID_2; // to cover fall-through case
- break main_loop;
- }
- char ch = _currSegment.charAt(_currSegmentPtr++);
- int bits = _variant.decodeBase64Char(ch);
- if (bits < 0) {
- if (bits != Base64Variant.BASE64_VALUE_PADDING) {
- throw reportInvalidChar(ch, 2);
- }
- // Padding is off the "fast path", so:
- _state = STATE_VALID_2_AND_PADDING;
- continue main_loop;
- }
- _decodedData = (_decodedData << 6) | bits;
- }
- // fall through, "fast path"
-
- case STATE_VALID_3:
- // fourth and last base64 char; can be padding, but not ws
- {
- if (_currSegmentPtr >= _currSegmentEnd) {
- _state = STATE_VALID_3; // to cover fall-through case
- break main_loop;
- }
- char ch = _currSegment.charAt(_currSegmentPtr++);
- int bits = _variant.decodeBase64Char(ch);
- if (bits < 0) {
- if (bits != Base64Variant.BASE64_VALUE_PADDING) {
- throw reportInvalidChar(ch, 3);
- }
- /* With padding we only get 2 bytes; but we have
- * to shift it a bit so it is identical to triplet
- * case with partial output.
- * 3 chars gives 3x6 == 18 bits, of which 2 are
- * dummies, need to discard:
- */
- _decodedData >>= 2;
- _state = STATE_OUTPUT_2;
- continue main_loop;
- }
- // otherwise, our triple is now complete
- _decodedData = (_decodedData << 6) | bits;
- }
- // still along fast path
-
- case STATE_OUTPUT_3:
- if (resultOffset >= resultBufferEnd) { // no room
- _state = STATE_OUTPUT_3;
- break main_loop;
- }
- resultBuffer[resultOffset++] = (byte) (_decodedData >> 16);
- // fall through
-
- case STATE_OUTPUT_2:
- if (resultOffset >= resultBufferEnd) { // no room
- _state = STATE_OUTPUT_2;
- break main_loop;
- }
- resultBuffer[resultOffset++] = (byte) (_decodedData >> 8);
- // fall through
-
- case STATE_OUTPUT_1:
- if (resultOffset >= resultBufferEnd) { // no room
- _state = STATE_OUTPUT_1;
- break main_loop;
- }
- resultBuffer[resultOffset++] = (byte) _decodedData;
- _state = STATE_INITIAL;
- continue main_loop;
-
- case STATE_VALID_2_AND_PADDING:
- {
- if (_currSegmentPtr >= _currSegmentEnd) {
- // must have valid state already (can't get in via fall-through)
- break main_loop;
- }
- char ch = _currSegment.charAt(_currSegmentPtr++);
- if (!_variant.usesPaddingChar(ch)) {
- throw reportInvalidChar(ch, 3, "expected padding character '='");
- }
- // Got 12 bits, only need 8, need to shift
- _state = STATE_OUTPUT_1;
- _decodedData >>= 4;
- }
- continue main_loop;
-
- default:
- // sanity check: should never happen
- throw new IllegalStateException("Illegal internal state "+_state);
- }
- }
- return resultOffset - origResultOffset;
- }
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/ValueDecoderFactory.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/ValueDecoderFactory.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/ValueDecoderFactory.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/ValueDecoderFactory.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,1429 +0,0 @@
-/* Reference Implementation of
- * Stax2 extension API (for basic Stax API, JSR-173)
- *
- * Copyright (c) 2008- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.typed;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-
-import org.codehaus.stax2.typed.TypedArrayDecoder;
-import org.codehaus.stax2.typed.TypedValueDecoder;
-
-/**
- * Factory class used to construct all
- * {@link org.codehaus.stax2.typed.TypedValueDecoder}
- * (and {@link org.codehaus.stax2.typed.TypedArrayDecoder})
- * instances needed by a
- * single stream reader instance. Some decoders are also recycled
- * (for the lifetime of an encoder, which is same as its owners,
- * i.e. stream reader or writer's) to minimize overhead.
- *
- * Since encoders may be recycled, instances are not thread-safe.
- *
- * @since 3.0
- */
-public final class ValueDecoderFactory
-{
- // // // Lazily-constructed, recycled decoder instances
- // // // (only for simple commonly needed types)
-
- protected BooleanDecoder mBooleanDecoder = null;
- protected IntDecoder mIntDecoder = null;
- protected LongDecoder mLongDecoder = null;
- protected FloatDecoder mFloatDecoder = null;
- protected DoubleDecoder mDoubleDecoder = null;
-
- public ValueDecoderFactory() { }
-
- /*
- /////////////////////////////////////////////////////
- // Factory methods, scalar decoders
- /////////////////////////////////////////////////////
- */
-
- public BooleanDecoder getBooleanDecoder()
- {
- if (mBooleanDecoder == null) {
- mBooleanDecoder = new BooleanDecoder();
- }
- return mBooleanDecoder;
- }
-
- public IntDecoder getIntDecoder()
- {
- if (mIntDecoder == null) {
- mIntDecoder = new IntDecoder();
- }
- return mIntDecoder;
- }
-
- public LongDecoder getLongDecoder()
- {
- if (mLongDecoder == null) {
- mLongDecoder = new LongDecoder();
- }
- return mLongDecoder;
- }
-
- public FloatDecoder getFloatDecoder()
- {
- if (mFloatDecoder == null) {
- mFloatDecoder = new FloatDecoder();
- }
- return mFloatDecoder;
- }
-
- public DoubleDecoder getDoubleDecoder()
- {
- if (mDoubleDecoder == null) {
- mDoubleDecoder = new DoubleDecoder();
- }
- return mDoubleDecoder;
- }
-
- // // // Other scalar decoders: not recycled
-
- public IntegerDecoder getIntegerDecoder() { return new IntegerDecoder(); }
-
- public DecimalDecoder getDecimalDecoder() { return new DecimalDecoder(); }
-
- public QNameDecoder getQNameDecoder(NamespaceContext nsc) {
- return new QNameDecoder(nsc);
- }
-
- /*
- /////////////////////////////////////////////////////
- // Factory methods, array decoders
- /////////////////////////////////////////////////////
- */
-
- /**
- * Method for constructing
- * integer array value decoder
- * that uses provided fixed array for storing results.
- */
- public IntArrayDecoder getIntArrayDecoder(int[] result, int offset, int len)
- {
- return new IntArrayDecoder(result, offset, len, getIntDecoder());
- }
-
- /**
- * Method for constructing
- * integer array value decoder
- * that automatically allocates and resizes result array as necessary.
- */
- public IntArrayDecoder getIntArrayDecoder()
- {
- return new IntArrayDecoder(getIntDecoder());
- }
-
- public LongArrayDecoder getLongArrayDecoder(long[] result, int offset, int len)
- {
- return new LongArrayDecoder(result, offset, len, getLongDecoder());
- }
-
- public LongArrayDecoder getLongArrayDecoder()
-
- {
- return new LongArrayDecoder(getLongDecoder());
- }
-
- public FloatArrayDecoder getFloatArrayDecoder(float[] result, int offset, int len)
- {
- return new FloatArrayDecoder(result, offset, len, getFloatDecoder());
- }
-
- public FloatArrayDecoder getFloatArrayDecoder()
-
- {
- return new FloatArrayDecoder(getFloatDecoder());
- }
-
- public DoubleArrayDecoder getDoubleArrayDecoder(double[] result, int offset, int len)
- {
- return new DoubleArrayDecoder(result, offset, len, getDoubleDecoder());
- }
-
- public DoubleArrayDecoder getDoubleArrayDecoder()
- {
- return new DoubleArrayDecoder(getDoubleDecoder());
- }
-
- /*
- /////////////////////////////////////////////////////
- // Shared decoder base class
- /////////////////////////////////////////////////////
- */
-
- /**
- * There are some things common to all textual decoders (like
- * white space trimming).
- */
- public abstract static class DecoderBase
- extends TypedValueDecoder
- {
- final static long L_BILLION = 1000000000;
-
- final static long L_MAX_INT = (long) Integer.MAX_VALUE;
-
- final static long L_MIN_INT = (long) Integer.MIN_VALUE;
-
- final static BigInteger BD_MIN_LONG = BigInteger.valueOf(Long.MIN_VALUE);
- final static BigInteger BD_MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE);
-
- /**
- * Pointer to the next character to check, within lexical value
- */
- protected int mNextPtr;
-
- protected DecoderBase() { }
-
- public abstract String getType();
-
- /**
- * Method called if the value to decode does not contain
- * any non-white space characters (including the case where
- * typed accessor is called for an empty element).
- */
- public void handleEmptyValue()
- {
- /* Defalt behavior for all types implemented within
- * this class is to just throw an exception
- */
- throw new IllegalArgumentException("Empty value (all white space) not a valid lexical representation of "+getType());
- }
-
- /*
- //////////////////////////////////////////////////
- // Shared methods, trimming
- //////////////////////////////////////////////////
- */
-
- /**
- * Method called to check that remaining String consists of zero or
- * more digits
- */
- protected void verifyDigits(String lexical, int start, int end)
- {
- for (; start < end; ++start) {
- char ch = lexical.charAt(start);
- if (ch > '9' || ch < '0') {
- throw constructInvalidValue(lexical);
- }
- }
- }
-
- protected void verifyDigits(char[] lexical, int start, int end, int ptr)
- {
- for (; ptr < end; ++ptr) {
- char ch = lexical[ptr];
- if (ch > '9' || ch < '0') {
- throw constructInvalidValue(lexical, start, end);
- }
- }
- }
-
- /**
- * @return Numeric value of the first non-zero character (or, in
- * case of a zero value, zero)
- */
- protected int skipSignAndZeroes(String lexical, char ch, boolean hasSign, final int end)
- {
- int ptr;
- // Then optional sign
- if (hasSign) {
- ptr = 1;
- if (ptr >= end) {
- throw constructInvalidValue(lexical);
- }
- ch = lexical.charAt(ptr++);
- } else {
- ptr = 1;
- }
-
- // Has to start with a digit
- int value = ch - '0';
- if (value < 0 || value > 9) {
- throw constructInvalidValue(lexical);
- }
-
- // Then, leading zero(es) to skip? (or just value zero itself)
- while (value == 0 && ptr < end) {
- int v2 = lexical.charAt(ptr) - '0';
- if (v2 < 0 || v2 > 9) {
- break;
- }
- ++ptr;
- value = v2;
- }
- mNextPtr = ptr;
- return value;
- }
-
- protected int skipSignAndZeroes(char[] lexical, char ch, boolean hasSign, final int start, final int end)
- {
- int ptr = start+1;
- if (hasSign) {
- if (ptr >= end) {
- throw constructInvalidValue(lexical, start, end);
- }
- ch = lexical[ptr++];
- }
-
- // Has to start with a digit
- int value = ch - '0';
- if (value < 0 || value > 9) {
- throw constructInvalidValue(lexical, start, end);
- }
-
- // Then leading zero(es) to skip? (or just value zero itself)
- while (value == 0 && ptr < end) {
- int v2 = lexical[ptr] - '0';
- if (v2 < 0 || v2 > 9) {
- break;
- }
- ++ptr;
- value = v2;
- }
- mNextPtr = ptr;
- return value;
- }
-
- /*
- ///////////////////////////////////////////////
- // Shared methods, int conversions
- ///////////////////////////////////////////////
- */
-
- /**
- * Fast method for parsing integers that are known to fit into
- * regular 32-bit signed int type. This means that length is
- * between 1 and 9 digits (inclusive)
- *
- * @return Parsed integer value
- */
- protected final static int parseInt(char[] digitChars, int start, int end)
- {
- /* This looks ugly, but appears to be the fastest way
- * (based on perf testing, profiling)
- */
- int num = digitChars[start] - '0';
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- }
- }
- }
- }
- }
- }
- }
- }
- return num;
- }
-
- protected final static int parseInt(int num, char[] digitChars, int start, int end)
- {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars[start] - '0');
- }
- }
- }
- }
- }
- }
- }
- return num;
- }
-
- protected final static int parseInt(String digitChars, int start, int end)
- {
- int num = digitChars.charAt(start) - '0';
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- }
- }
- }
- }
- }
- }
- }
- }
- return num;
- }
-
- protected final static int parseInt(int num, String digitChars, int start, int end)
- {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- if (++start < end) {
- num = (num * 10) + (digitChars.charAt(start) - '0');
- }
- }
- }
- }
- }
- }
- }
- return num;
- }
-
- protected final static long parseLong(char[] digitChars, int start, int end)
- {
- // Note: caller must ensure length is [10, 18]
- int start2 = end-9;
- long val = parseInt(digitChars, start, start2) * L_BILLION;
- return val + (long) parseInt(digitChars, start2, end);
- }
-
- protected final static long parseLong(String digitChars, int start, int end)
- {
- // Note: caller must ensure length is [10, 18]
- int start2 = end-9;
- long val = parseInt(digitChars, start, start2) * L_BILLION;
- return val + (long) parseInt(digitChars, start2, end);
- }
-
- /*
- ///////////////////////////////////////////////
- // Shared methods, error reporting
- ///////////////////////////////////////////////
- */
-
- protected IllegalArgumentException constructInvalidValue(String lexical)
- {
- // !!! Should we escape ctrl+chars etc?
- return new IllegalArgumentException("Value \""+lexical+"\" not a valid lexical representation of "+getType());
- }
-
- protected IllegalArgumentException constructInvalidValue(char[] lexical, int startOffset, int end)
- {
- return new IllegalArgumentException("Value \""+lexicalDesc(lexical, startOffset, end)+"\" not a valid lexical representation of "+getType());
- }
-
- protected String lexicalDesc(char[] lexical, int startOffset, int end)
- {
- return _clean(new String(lexical, startOffset, end-startOffset));
- }
-
- protected String lexicalDesc(String lexical)
- {
- return _clean(lexical);
- }
-
- protected String _clean(String str)
- {
- // !!! Should we escape ctrl+chars etc?
- return str.trim();
- }
- }
-
- /*
- /////////////////////////////////////////////////////
- // Decoders, scalar primitives
- /////////////////////////////////////////////////////
- */
-
- public final static class BooleanDecoder
- extends DecoderBase
- {
- protected boolean mValue;
-
- public BooleanDecoder() { }
-
- public String getType() { return "boolean"; }
-
- public boolean getValue() { return mValue; }
-
- public void decode(String lexical)
- throws IllegalArgumentException
- {
- int len = lexical.length();
- char c = lexical.charAt(0);
- if (c == 't') {
- if (len == 4
- && lexical.charAt(1) == 'r'
- && lexical.charAt(2) == 'u'
- && lexical.charAt(3) == 'e') {
- mValue = true;
- return;
- }
- } else if (c == 'f') {
- if (len == 5
- && lexical.charAt(1) == 'a'
- && lexical.charAt(2) == 'l'
- && lexical.charAt(3) == 's'
- && lexical.charAt(4) == 'e') {
- mValue = false;
- return;
- }
- } else if (c == '0') {
- if (len == 1) {
- mValue = false;
- return;
- }
- } else if (c == '1') {
- if (len == 1) {
- mValue = true;
- return;
- }
- }
- throw constructInvalidValue(lexical);
- }
-
- public void decode(char[] lexical, int start, int end)
- throws IllegalArgumentException
- {
- // First, skip leading ws if any
- int len = end-start;
- char c = lexical[start];
- if (c == 't') {
- if (len == 4
- && lexical[start+1] == 'r'
- && lexical[start+2] == 'u'
- && lexical[start+3] == 'e') {
- mValue = true;
- return;
- }
- } else if (c == 'f') {
- if (len == 5
- && lexical[start+1] == 'a'
- && lexical[start+2] == 'l'
- && lexical[start+3] == 's'
- && lexical[start+4] == 'e') {
- mValue = false;
- return;
- }
- } else if (c == '0') {
- if (len == 1) {
- mValue = false;
- return;
- }
- } else if (c == '1') {
- if (len == 1) {
- mValue = true;
- return;
- }
- }
- throw constructInvalidValue(lexical, start, end);
- }
- }
-
- public final static class IntDecoder
- extends DecoderBase
- {
- protected int mValue;
-
- public IntDecoder() { }
-
- public String getType() { return "int"; }
-
- public int getValue() { return mValue; }
-
- public void decode(String lexical)
- throws IllegalArgumentException
- {
- final int end = lexical.length();
- char ch = lexical.charAt(0);
- boolean neg = (ch == '-');
- int nr;
-
- if (neg || (ch == '+')) {
- nr = skipSignAndZeroes(lexical, ch, true, end);
- } else {
- nr = skipSignAndZeroes(lexical, ch, false, end);
- }
- int ptr = mNextPtr;
-
- // Otherwise, need to verify that is [digit*][ws*]
- int charsLeft = end-ptr;
- if (charsLeft == 0) {
- mValue = neg ? -nr : nr;
- return;
- }
- verifyDigits(lexical, ptr, end);
- // Note: charsLeft one less than total length (skipped first digit)
- if (charsLeft <= 8) { // no overflow
- int i = parseInt(nr, lexical, ptr, ptr+charsLeft);
- mValue = neg ? -i : i;
- return;
- }
- // Otherwise, may have overflow
- // Max 10 digits for a legal int
- if (charsLeft == 9 && nr < 3) { // min/max is ~2 billion (+/-)
- long base = L_BILLION;
- if (nr == 2) {
- base += L_BILLION;
- }
- int i = parseInt(lexical, ptr, ptr+charsLeft);
- long l = base + (long) i;
- if (neg) {
- l = -l;
- if (l >= L_MIN_INT) {
- mValue = (int) l;
- return;
- }
- } else {
- if (l <= L_MAX_INT) {
- mValue = (int) l;
- return;
- }
- }
- }
- throw new IllegalArgumentException("value \""+lexicalDesc(lexical)+"\" not a valid 32-bit integer: overflow.");
-
- }
-
- public void decode(char[] lexical, final int start, final int end)
- throws IllegalArgumentException
- {
- char ch = lexical[start];
- boolean neg = (ch == '-');
- int nr;
-
- if (neg || (ch == '+')) {
- nr = skipSignAndZeroes(lexical, ch, true, start, end);
- } else {
- nr = skipSignAndZeroes(lexical, ch, false, start, end);
- }
- int ptr = mNextPtr;
-
- // Quick check for short (single-digit) values:
- int charsLeft = end-ptr;
- if (charsLeft == 0) {
- mValue = neg ? -nr : nr;
- return;
- }
- verifyDigits(lexical, start, end, ptr);
- // Note: charsLeft one less than total length (skipped first digit)
- // Can parse more cheaply, if it's really just an int...
- if (charsLeft <= 8) { // no overflow
- int i = parseInt(nr, lexical, ptr, ptr+charsLeft);
- mValue = neg ? -i : i;
- return;
- }
- // Otherwise, may have overflow
- // Max 10 digits for a legal int
- if (charsLeft == 9 && nr < 3) { // min/max is ~2 billion (+/-)
- long base = L_BILLION;
- if (nr == 2) {
- base += L_BILLION;
- }
- int i = parseInt(lexical, ptr, ptr+charsLeft);
- long l = base + (long) i;
- if (neg) {
- l = -l;
- if (l >= L_MIN_INT) {
- mValue = (int) l;
- return;
- }
- } else {
- if (l <= L_MAX_INT) {
- mValue = (int) l;
- return;
- }
- }
- }
- throw new IllegalArgumentException("value \""+lexicalDesc(lexical, start, end)+"\" not a valid 32-bit integer: overflow.");
- }
- }
-
- public final static class LongDecoder
- extends DecoderBase
- {
- protected long mValue;
-
- public LongDecoder() { }
-
- public String getType() { return "long"; }
-
- public long getValue() { return mValue; }
-
- public void decode(String lexical)
- throws IllegalArgumentException
- {
- final int end = lexical.length();
- char ch = lexical.charAt(0);
- boolean neg = (ch == '-');
- int nr;
-
- if (neg || (ch == '+')) {
- nr = skipSignAndZeroes(lexical, ch, true, end);
- } else {
- nr = skipSignAndZeroes(lexical, ch, false, end);
- }
- int ptr = mNextPtr;
-
- // Quick check for short (single-digit) values:
- int charsLeft = end-ptr;
- if (charsLeft == 0) {
- mValue = (long) (neg ? -nr : nr);
- return;
- }
- verifyDigits(lexical, ptr, end);
- // Note: charsLeft one less than total length (skipped first digit)
- // Can parse more cheaply, if it's really just an int...
- if (charsLeft <= 8) { // no overflow
- int i = parseInt(nr, lexical, ptr, ptr+charsLeft);
- mValue = (long) (neg ? -i : i);
- return;
- }
- // At this point, let's just push back the first digit... simpler
- --ptr;
- ++charsLeft;
-
- // Still simple long?
- if (charsLeft <= 18) {
- long l = parseLong(lexical, ptr, ptr+charsLeft);
- mValue = neg ? -l : l;
- return;
- }
- /* Otherwise, let's just fallback to an expensive option,
- * BigInteger. While relatively inefficient, it's simple
- * to use, reliable etc.
- */
- mValue = parseUsingBD(lexical.substring(ptr, ptr+charsLeft), neg);
- }
-
- public void decode(char[] lexical, final int start, final int end)
- throws IllegalArgumentException
- {
- char ch = lexical[start];
- boolean neg = (ch == '-');
- int nr;
-
- if (neg || (ch == '+')) {
- nr = skipSignAndZeroes(lexical, ch, true, start, end);
- } else {
- nr = skipSignAndZeroes(lexical, ch, false, start, end);
- }
- int ptr = mNextPtr;
-
- // Quick check for short (single-digit) values:
- int charsLeft = end-ptr;
- if (charsLeft == 0) {
- mValue = (long) (neg ? -nr : nr);
- return;
- }
- verifyDigits(lexical, start, end, ptr);
- // Note: charsLeft one less than total length (skipped first digit)
- // Can parse more cheaply, if it's really just an int...
- if (charsLeft <= 8) { // no overflow
- int i = parseInt(nr, lexical, ptr, ptr+charsLeft);
- mValue = neg ? -i : i;
- return;
- }
- // At this point, let's just push back the first digit... simpler
- --ptr;
- ++charsLeft;
-
- // Still simple long?
- if (charsLeft <= 18) {
- long l = parseLong(lexical, ptr, ptr+charsLeft);
- mValue = neg ? -l : l;
- return;
- }
-
- // Otherwise, let's just fallback to an expensive option
- mValue = parseUsingBD(new String(lexical, ptr, charsLeft), neg);
- }
-
- private long parseUsingBD(String lexical, boolean neg)
- {
- BigInteger bi = new BigInteger(lexical);
-
- // But we may over/underflow, let's check:
- if (neg) {
- bi = bi.negate();
- if (bi.compareTo(BD_MIN_LONG) >= 0) {
- return bi.longValue();
- }
- } else {
- if (bi.compareTo(BD_MAX_LONG) <= 0) {
- return bi.longValue();
- }
- }
-
- throw new IllegalArgumentException("value \""+lexicalDesc(lexical)+"\" not a valid long: overflow.");
- }
- }
-
- public final static class FloatDecoder
- extends DecoderBase
- {
- protected float mValue;
-
- public FloatDecoder() { }
-
- public String getType() { return "float"; }
-
- public float getValue() { return mValue; }
-
- public void decode(String lexical)
- throws IllegalArgumentException
- {
- /* Then, leading digit; or one of 3 well-known constants
- * (INF, -INF, NaN)
- */
- int len = lexical.length();
- if (len == 3) {
- char c = lexical.charAt(0);
- if (c == 'I') {
- if (lexical.charAt(1) == 'N' && lexical.charAt(2) == 'F') {
- mValue = Float.POSITIVE_INFINITY;
- return;
- }
- } else if (c == 'N') {
- if (lexical.charAt(1) == 'a' && lexical.charAt(2) == 'N') {
- mValue = Float.NaN;
- return;
- }
- }
- } else if (len == 4) {
- char c = lexical.charAt(0);
- if (c == '-') {
- if (lexical.charAt(1) == 'I'
- && lexical.charAt(2) == 'N'
- && lexical.charAt(3) == 'F') {
- mValue = Float.NEGATIVE_INFINITY;
- return;
- }
- }
- }
-
- try {
- mValue = Float.parseFloat(lexical);
- } catch (NumberFormatException nex) {
- throw constructInvalidValue(lexical);
- }
- }
-
- public void decode(char[] lexical, int start, int end)
- throws IllegalArgumentException
- {
- int len = end-start;
-
- if (len == 3) {
- char c = lexical[start];
- if (c == 'I') {
- if (lexical[start+1] == 'N' && lexical[start+2] == 'F') {
- mValue = Float.POSITIVE_INFINITY;
- return;
- }
- } else if (c == 'N') {
- if (lexical[start+1] == 'a' && lexical[start+2] == 'N') {
- mValue = Float.NaN;
- return;
- }
- }
- } else if (len == 4) {
- char c = lexical[start];
- if (c == '-') {
- if (lexical[start+1] == 'I'
- && lexical[start+2] == 'N'
- && lexical[start+3] == 'F') {
- mValue = Float.NEGATIVE_INFINITY;
- return;
- }
- }
- }
-
- String lexicalStr = new String(lexical, start, len);
- try {
- mValue = Float.parseFloat(lexicalStr);
- } catch (NumberFormatException nex) {
- throw constructInvalidValue(lexicalStr);
- }
- }
- }
-
- public final static class DoubleDecoder
- extends DecoderBase
- {
- protected double mValue;
-
- public DoubleDecoder() { }
-
- public String getType() { return "double"; }
-
- public double getValue() { return mValue; }
-
- public void decode(String lexical)
- throws IllegalArgumentException
- {
- /* Then, leading digit; or one of 3 well-known constants
- * (INF, -INF, NaN)
- */
- int len = lexical.length();
- if (len == 3) {
- char c = lexical.charAt(0);
- if (c == 'I') {
- if (lexical.charAt(1) == 'N' && lexical.charAt(2) == 'F') {
- mValue = Double.POSITIVE_INFINITY;
- return;
- }
- } else if (c == 'N') {
- if (lexical.charAt(1) == 'a' && lexical.charAt(2) == 'N') {
- mValue = Double.NaN;
- return;
- }
- }
- } else if (len == 4) {
- char c = lexical.charAt(0);
- if (c == '-') {
- if (lexical.charAt(1) == 'I'
- && lexical.charAt(2) == 'N'
- && lexical.charAt(3) == 'F') {
- mValue = Double.NEGATIVE_INFINITY;
- return;
- }
- }
- }
-
- try {
- mValue = Double.parseDouble(lexical);
- } catch (NumberFormatException nex) {
- throw constructInvalidValue(lexical);
- }
- }
-
- public void decode(char[] lexical, int start, int end)
- throws IllegalArgumentException
- {
- int len = end-start;
-
- if (len == 3) {
- char c = lexical[start];
- if (c == 'I') {
- if (lexical[start+1] == 'N' && lexical[start+2] == 'F') {
- mValue = Double.POSITIVE_INFINITY;
- return;
- }
- } else if (c == 'N') {
- if (lexical[start+1] == 'a' && lexical[start+2] == 'N') {
- mValue = Double.NaN;
- return;
- }
- }
- } else if (len == 4) {
- char c = lexical[start];
- if (c == '-') {
- if (lexical[start+1] == 'I'
- && lexical[start+2] == 'N'
- && lexical[start+3] == 'F') {
- mValue = Double.NEGATIVE_INFINITY;
- return;
- }
- }
- }
-
- String lexicalStr = new String(lexical, start, len);
- try {
- mValue = Double.parseDouble(lexicalStr);
- } catch (NumberFormatException nex) {
- throw constructInvalidValue(lexicalStr);
- }
- }
- }
-
- /*
- /////////////////////////////////////////////////////
- // Decoders, other scalars
- /////////////////////////////////////////////////////
- */
-
- public final static class IntegerDecoder
- extends DecoderBase
- {
- protected BigInteger mValue;
-
- public IntegerDecoder() { }
-
- public String getType() { return "integer"; }
-
- public BigInteger getValue() { return mValue; }
-
- public void decode(String lexical) throws IllegalArgumentException
- {
- try {
- mValue = new BigInteger(lexical);
- } catch (NumberFormatException nex) {
- throw constructInvalidValue(lexical);
- }
- }
-
- public void decode(char[] lexical, int start, int end) throws IllegalArgumentException
- {
- String lexicalStr = new String(lexical, start, (end-start));
- try {
- mValue = new BigInteger(lexicalStr);
- } catch (NumberFormatException nex) {
- throw constructInvalidValue(lexicalStr);
- }
- }
- }
-
- public final static class DecimalDecoder
- extends DecoderBase
- {
- protected BigDecimal mValue;
-
- public DecimalDecoder() { }
-
- public String getType() { return "decimal"; }
-
- public BigDecimal getValue() { return mValue; }
-
- public void decode(String lexical) throws IllegalArgumentException
- {
- try {
- mValue = new BigDecimal(lexical);
- } catch (NumberFormatException nex) {
- throw constructInvalidValue(lexical);
- }
- }
-
- public void decode(char[] lexical, int start, int end) throws IllegalArgumentException
- {
- int len = end-start;
- try {
- /* !!! 21-Nov-2008, TSa: This constructor was added in JDK1.5
- * so can't yet be used (As of Woodstox 4.x).
- * Need to use the older constructor for now
- */
- //mValue = new BigDecimal(lexical, start, len);
- mValue = new BigDecimal(new String(lexical, start, len));
- } catch (NumberFormatException nex) {
- throw constructInvalidValue(new String(lexical, start, len));
- }
- }
- }
-
- public final static class QNameDecoder
- extends DecoderBase
- {
- final NamespaceContext mNsCtxt;
-
- protected QName mValue;
-
- public QNameDecoder(NamespaceContext nsc) {
- mNsCtxt = nsc;
- }
-
- public String getType() { return "QName"; }
-
- public QName getValue() { return mValue; }
-
- public void decode(String lexical) throws IllegalArgumentException
- {
- int ix = lexical.indexOf(':');
- if (ix >= 0) { // qualified name
- mValue = resolveQName(lexical.substring(0, ix),
- lexical.substring(ix+1));
- } else {
- mValue = resolveQName(lexical);
- }
- }
-
- public void decode(char[] lexical, int start, int end) throws IllegalArgumentException
- {
- int i = start;
- for (; i < end; ++i) {
- if (lexical[i] == ':') {
- mValue = resolveQName(new String(lexical, start, i-start),
- new String(lexical, i+1, end-i-1));
- return;
- }
- }
- mValue = resolveQName(new String(lexical, start, end-start));
- }
-
- protected QName resolveQName(String localName) throws IllegalArgumentException
- {
- // No prefix -> default namespace ("element rules")
- String uri = mNsCtxt.getNamespaceURI("");
- if (uri == null) { // some impls may return null
- uri = "";
- }
- return new QName(uri, localName);
- }
-
- protected QName resolveQName(String prefix, String localName)
- throws IllegalArgumentException
- {
- if (prefix.length() == 0 || localName.length() == 0) {
- // either prefix or local name is empty String, illegal
- throw constructInvalidValue(prefix+":"+localName);
- }
- /* Explicit prefix, must map to a bound namespace; and that
- * namespace can not be empty (only "no prefix", i.e. 'default
- * namespace' has empty URI)
- */
- String uri = mNsCtxt.getNamespaceURI(prefix);
- if (uri == null || uri.length() == 0) {
- throw new IllegalArgumentException("Value \""+lexicalDesc(prefix+":"+localName)+"\" not a valid QName: prefix '"+prefix+"' not bound to a namespace");
- }
- return new QName(uri, localName, prefix);
- }
- }
-
- /*
- /////////////////////////////////////////////////////
- // Decoders, array
- /////////////////////////////////////////////////////
- */
-
- /**
- * Intermediate shared base class for token array decoders.
- * The most important additional part is the abstract method
- * that can be used to expand storage space; this is needed
- * when decoding attribute values when all values must fit
- * in the result array.
- */
- public abstract static class BaseArrayDecoder
- extends TypedArrayDecoder
- {
- /**
- * Let's use some modest array size for allocating initial
- * result buffer
- */
- protected final static int INITIAL_RESULT_BUFFER_SIZE = 40;
-
- /**
- * When expanding 'small' result buffers, we will expand
- * size by bigger factor than for larger ones.
- */
- protected final static int SMALL_RESULT_BUFFER_SIZE = 4000;
-
- protected int mStart;
-
- protected int mEnd;
-
- protected int mCount = 0;
-
- protected BaseArrayDecoder(int start, int maxCount)
- {
- mStart = start;
- // First, sanity check
- if (maxCount < 1) {
- throw new IllegalArgumentException("Number of elements to read can not be less than 1");
- }
- mEnd = maxCount;
- }
-
- public final int getCount() { return mCount; }
- public final boolean hasRoom() { return mCount < mEnd; }
-
- /**
- * Method that can be called if the internal result buffer
- * fills up (when {@link #hasRoom} returns false) and
- * will expand result buffer to hold at least one more value.
- */
- public abstract void expand();
-
- protected int calcNewSize(int currSize)
- {
- if (currSize < SMALL_RESULT_BUFFER_SIZE) {
- return currSize << 2; // 4 x current for small bufs
- }
- return currSize+currSize; // 2x for bigger
- }
- }
-
- public final static class IntArrayDecoder
- extends BaseArrayDecoder
- {
- int[] mResult;
-
- final IntDecoder mDecoder;
-
- /**
- * Constructor used for constructing decoders with fixed pre-allocated
- * result buffer.
- */
- public IntArrayDecoder(int[] result, int start, int maxCount,
- IntDecoder intDecoder)
- {
- super(start, maxCount);
- mResult = result;
- mDecoder = intDecoder;
- }
-
- /**
- * Constructor used for constructing decoders with automatically
- * adjusting result buffer
- */
- public IntArrayDecoder(IntDecoder intDecoder)
- {
- super(0, INITIAL_RESULT_BUFFER_SIZE);
- mResult = new int[INITIAL_RESULT_BUFFER_SIZE];
- mDecoder = intDecoder;
- }
-
- public void expand()
- {
- int[] old = mResult;
- int oldLen = old.length;
- int newSize = calcNewSize(oldLen);
- mResult = new int[newSize];
- System.arraycopy(old, mStart, mResult, 0, oldLen);
- mStart = 0;
- mEnd = newSize;
- }
-
- public int[] getValues()
- {
- int[] result = new int[mCount];
- // !!! TBI: with JDK 6, use Arrays.copyOf:
- System.arraycopy(mResult, mStart, result, 0, mCount);
- return result;
- }
-
- public boolean decodeValue(String input) throws IllegalArgumentException
- {
- mDecoder.decode(input);
- mResult[mStart+mCount] = mDecoder.getValue();
- return (++mCount >= mEnd);
- }
-
- public boolean decodeValue(char[] buffer, int start, int end) throws IllegalArgumentException
- {
- mDecoder.decode(buffer, start, end);
- mResult[mStart+mCount] = mDecoder.getValue();
- return (++mCount >= mEnd);
- }
-
- }
-
- public final static class LongArrayDecoder
- extends BaseArrayDecoder
- {
- long[] mResult;
-
- final LongDecoder mDecoder;
-
- public LongArrayDecoder(long[] result, int start, int maxCount,
- LongDecoder longDecoder)
- {
- super(start, maxCount);
- mResult = result;
- mDecoder = longDecoder;
- }
-
- public LongArrayDecoder(LongDecoder longDecoder)
- {
- super(0, INITIAL_RESULT_BUFFER_SIZE);
- mResult = new long[INITIAL_RESULT_BUFFER_SIZE];
- mDecoder = longDecoder;
- }
-
- public void expand()
- {
- long[] old = mResult;
- int oldLen = old.length;
- int newSize = calcNewSize(oldLen);
- mResult = new long[newSize];
- System.arraycopy(old, mStart, mResult, 0, oldLen);
- mStart = 0;
- mEnd = newSize;
- }
-
- public long[] getValues()
- {
- long[] result = new long[mCount];
- System.arraycopy(mResult, mStart, result, 0, mCount);
- return result;
- }
-
- public boolean decodeValue(String input) throws IllegalArgumentException
- {
- mDecoder.decode(input);
- mResult[mStart+mCount] = mDecoder.getValue();
- return (++mCount >= mEnd);
- }
-
- public boolean decodeValue(char[] buffer, int start, int end) throws IllegalArgumentException
- {
- mDecoder.decode(buffer, start, end);
- mResult[mStart+mCount] = mDecoder.getValue();
- return (++mCount >= mEnd);
- }
- }
-
- public final static class FloatArrayDecoder
- extends BaseArrayDecoder
- {
- float[] mResult;
-
- final FloatDecoder mDecoder;
-
- public FloatArrayDecoder(float[] result, int start, int maxCount,
- FloatDecoder floatDecoder)
- {
- super(start, maxCount);
- mResult = result;
- mDecoder = floatDecoder;
- }
-
- public FloatArrayDecoder(FloatDecoder floatDecoder)
- {
- super(0, INITIAL_RESULT_BUFFER_SIZE);
- mResult = new float[INITIAL_RESULT_BUFFER_SIZE];
- mDecoder = floatDecoder;
- }
-
- public void expand()
- {
- float[] old = mResult;
- int oldLen = old.length;
- int newSize = calcNewSize(oldLen);
- mResult = new float[newSize];
- System.arraycopy(old, mStart, mResult, 0, oldLen);
- mStart = 0;
- mEnd = newSize;
- }
-
- public float[] getValues()
- {
- float[] result = new float[mCount];
- System.arraycopy(mResult, mStart, result, 0, mCount);
- return result;
- }
-
- public boolean decodeValue(String input) throws IllegalArgumentException
- {
- mDecoder.decode(input);
- mResult[mStart+mCount] = mDecoder.getValue();
- return (++mCount >= mEnd);
- }
-
- public boolean decodeValue(char[] buffer, int start, int end) throws IllegalArgumentException
- {
- mDecoder.decode(buffer, start, end);
- mResult[mStart+mCount] = mDecoder.getValue();
- return (++mCount >= mEnd);
- }
- }
-
- public final static class DoubleArrayDecoder
- extends BaseArrayDecoder
- {
- double[] mResult;
-
- final DoubleDecoder mDecoder;
-
- public DoubleArrayDecoder(double[] result, int start, int maxCount,
- DoubleDecoder doubleDecoder)
- {
- super(start, maxCount);
- mResult = result;
- mDecoder = doubleDecoder;
- }
-
- public DoubleArrayDecoder(DoubleDecoder doubleDecoder)
- {
- super(0, INITIAL_RESULT_BUFFER_SIZE);
- mResult = new double[INITIAL_RESULT_BUFFER_SIZE];
- mDecoder = doubleDecoder;
- }
-
- public void expand()
- {
- double[] old = mResult;
- int oldLen = old.length;
- int newSize = calcNewSize(oldLen);
- mResult = new double[newSize];
- System.arraycopy(old, mStart, mResult, 0, oldLen);
- mStart = 0;
- mEnd = newSize;
- }
-
- public double[] getValues()
- {
- double[] result = new double[mCount];
- System.arraycopy(mResult, mStart, result, 0, mCount);
- return result;
- }
-
- public boolean decodeValue(String input) throws IllegalArgumentException
- {
- mDecoder.decode(input);
- mResult[mStart+mCount] = mDecoder.getValue();
- return (++mCount >= mEnd);
- }
-
- public boolean decodeValue(char[] buffer, int start, int end) throws IllegalArgumentException
- {
- mDecoder.decode(buffer, start, end);
- mResult[mStart+mCount] = mDecoder.getValue();
- return (++mCount >= mEnd);
- }
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/ValueEncoderFactory.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/ValueEncoderFactory.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/ValueEncoderFactory.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/ValueEncoderFactory.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,627 +0,0 @@
-/* Reference Implementation of
- * Stax2 extension API (for basic Stax API, JSR-173)
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.typed;
-
-import org.codehaus.stax2.typed.Base64Variant;
-
-/**
- * Factory class used to construct all
- * {@link AsciiValueEncoder} instances needed by a single
- * stream writer instance. Simple encoders are also recycled
- * (for the lifetime of an encoder, which is same as its owners,
- * i.e. stream reader or writer's) to minimize overhead.
- * More complex ones (array based, long string) are not recycled.
- *
- * Since encoders are recycled, instances are not thread-safe.
- *
- * @since 3.0
- */
-public final class ValueEncoderFactory
-{
- final static byte BYTE_SPACE = (byte) ' ';
-
- // // // Lazily-constructed, recycled encoder instances
-
- protected TokenEncoder _tokenEncoder = null;
- protected IntEncoder _intEncoder = null;
- protected LongEncoder _longEncoder = null;
- protected FloatEncoder _floatEncoder = null;
- protected DoubleEncoder _doubleEncoder = null;
-
- public ValueEncoderFactory() { }
-
- // // // Scalar encoder access
-
- public ScalarEncoder getScalarEncoder(String value)
- {
- // Short or long?
- if (value.length() > AsciiValueEncoder.MIN_CHARS_WITHOUT_FLUSH) { // short
- if (_tokenEncoder == null) {
- _tokenEncoder = new TokenEncoder();
- }
- _tokenEncoder.reset(value);
- return _tokenEncoder;
- }
- // Nope, long: need segmented
- return new StringEncoder(value);
- }
-
- public ScalarEncoder getEncoder(boolean value)
- {
- // !!! TBI: optimize
- return getScalarEncoder(value ? "true" : "false");
- }
-
- public IntEncoder getEncoder(int value)
- {
- if (_intEncoder == null) {
- _intEncoder = new IntEncoder();
- }
- _intEncoder.reset(value);
- return _intEncoder;
- }
-
- public LongEncoder getEncoder(long value)
- {
- if (_longEncoder == null) {
- _longEncoder = new LongEncoder();
- }
- _longEncoder.reset(value);
- return _longEncoder;
- }
-
- public FloatEncoder getEncoder(float value)
- {
- if (_floatEncoder == null) {
- _floatEncoder = new FloatEncoder();
- }
- _floatEncoder.reset(value);
- return _floatEncoder;
- }
-
- public DoubleEncoder getEncoder(double value)
- {
- if (_doubleEncoder == null) {
- _doubleEncoder = new DoubleEncoder();
- }
- _doubleEncoder.reset(value);
- return _doubleEncoder;
- }
-
- // // // Array encoder access
-
- public IntArrayEncoder getEncoder(int[] values, int from, int length)
- {
- return new IntArrayEncoder(values, from, from+length);
- }
-
- public LongArrayEncoder getEncoder(long[] values, int from, int length)
- {
- return new LongArrayEncoder(values, from, from+length);
- }
-
- public FloatArrayEncoder getEncoder(float[] values, int from, int length)
- {
- return new FloatArrayEncoder(values, from, from+length);
- }
-
- public DoubleArrayEncoder getEncoder(double[] values, int from, int length)
- {
- return new DoubleArrayEncoder(values, from, from+length);
- }
-
- // // // And special one for Base64
-
- public Base64Encoder getEncoder(Base64Variant v, byte[] data, int from, int length)
- {
- return new Base64Encoder(v, data, from, from+length);
- }
-
- /*
- ////////////////////////////////////////////////////////////////
- // Implementation classes; first, scalar (single-value) encoders
- ////////////////////////////////////////////////////////////////
- */
-
- /**
- * Intermediate base class for encoders that deal with single
- * primitive values.
- *
- * No default implementations, because textual and typed
- * (non-textual) sub-classes differ significantly.
- * In a way, this is just a tag class
- */
- abstract static class ScalarEncoder
- extends AsciiValueEncoder
- {
- protected ScalarEncoder() { }
- }
-
- /**
- * Implementation of textual encoder that operates on short
- * textual values ("tokens"). As such, it can count on being able
- * to output the whole output in one pass, without tracking
- * location
- */
- final static class TokenEncoder
- extends ScalarEncoder
- {
- String _value;
-
- protected TokenEncoder() { super(); }
-
- protected void reset(String value) {
- _value = value;
- }
-
- public boolean isCompleted() { return (_value == null); }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- String str = _value;
- _value = null;
- int len = str.length();
- str.getChars(0, len, buffer, ptr);
- ptr += len;
- return ptr;
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- String str = _value;
- _value = null;
- int len = str.length();
- for (int i = 0; i < len; ++i) {
- buffer[ptr++] = (byte) str.charAt(i);
- }
- return ptr;
- }
- }
-
- /**
- * Implementation of textual encoder that operates on longer
- * textual values. Because of length, it is possible that output
- * has to be done in multiple pieces. As a result, there is need
- * to track current position withing text.
- *
- * In addition, instances of this class are not recycled, as
- * it seems less beneficial (less likely to need to be reused,
- * or offer performance improvements if they would be)
- */
- final static class StringEncoder
- extends ScalarEncoder
- {
- String _value;
-
- int _offset;
-
- protected StringEncoder(String value) {
- super();
- _value = value;
- }
-
- public boolean isCompleted() { return (_value == null); }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- int left = _value.length() - _offset;
- int free = end-ptr;
- if (free >= left) { // completed, simple
- _value.getChars(_offset, left, buffer, ptr);
- _value = null;
- return (ptr+left);
- }
- _value.getChars(_offset, free, buffer, ptr);
- _offset += free;
- return end;
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- int left = _value.length() - _offset;
- int free = end-ptr;
- if (free >= left) { // completed, simple
- String str = _value;
- _value = null;
- for (int last = str.length(), offset = _offset; offset < last; ++offset) {
- buffer[ptr++] = (byte) str.charAt(offset);
- }
- return ptr;
- }
- for (; ptr < end; ++ptr) {
- buffer[ptr] = (byte) _value.charAt(_offset++);
- }
- return ptr;
- }
- }
-
- /**
- * Intermediate base class for typed (non-textual) scalar values
- */
- abstract static class TypedScalarEncoder
- extends ScalarEncoder
- {
- protected TypedScalarEncoder() { }
-
- /**
- * Since scalar typed values are guaranteed to always be
- * written in one go, they will always be completed by
- * time method is called./
- */
- public final boolean isCompleted() { return true; }
- }
-
- final static class IntEncoder
- extends TypedScalarEncoder
- {
- int _value;
-
- protected IntEncoder() { super(); }
-
- protected void reset(int value) {
- _value = value;
- }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- return NumberUtil.writeInt(_value, buffer, ptr);
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- return NumberUtil.writeInt(_value, buffer, ptr);
- }
- }
-
- final static class LongEncoder
- extends TypedScalarEncoder
- {
- long _value;
-
- protected LongEncoder() { super(); }
-
- protected void reset(long value) {
- _value = value;
- }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- return NumberUtil.writeLong(_value, buffer, ptr);
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- return NumberUtil.writeLong(_value, buffer, ptr);
- }
- }
-
- final static class FloatEncoder
- extends TypedScalarEncoder
- {
- float _value;
-
- protected FloatEncoder() { super(); }
-
- protected void reset(float value) {
- _value = value;
- }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- return NumberUtil.writeFloat(_value, buffer, ptr);
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- return NumberUtil.writeFloat(_value, buffer, ptr);
- }
- }
-
- final static class DoubleEncoder
- extends TypedScalarEncoder
- {
- double _value;
-
- protected DoubleEncoder() { super(); }
-
- protected void reset(double value) {
- _value = value;
- }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- return NumberUtil.writeDouble(_value, buffer, ptr);
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- return NumberUtil.writeDouble(_value, buffer, ptr);
- }
- }
-
- /*
- ////////////////////////////////////////////////////////////////
- // Implementation classes; array encoders
- ////////////////////////////////////////////////////////////////
- */
-
- /**
- * Intermediate base class for encoders that deal with arrays
- * of values.
- */
- abstract static class ArrayEncoder
- extends AsciiValueEncoder
- {
- int _ptr;
- final int _end;
-
- protected ArrayEncoder(int ptr, int end)
- {
- _ptr = ptr;
- _end = end;
- }
-
- public final boolean isCompleted() { return (_ptr >= _end); }
-
- public abstract int encodeMore(char[] buffer, int ptr, int end);
- }
-
- /**
- * Concrete implementation used for encoding int[] content.
- */
- final static class IntArrayEncoder
- extends ArrayEncoder
- {
- final int[] _values;
-
- protected IntArrayEncoder(int[] values, int from, int length)
- {
- super(from, length);
- _values = values;
- }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- int lastOk = end - (1+NumberUtil.MAX_INT_CLEN);
- while (ptr <= lastOk && _ptr < _end) {
- buffer[ptr++] = ' ';
- ptr = NumberUtil.writeInt(_values[_ptr++], buffer, ptr);
- }
- return ptr;
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- int lastOk = end - (1+NumberUtil.MAX_INT_CLEN);
- while (ptr <= lastOk && _ptr < _end) {
- buffer[ptr++] = BYTE_SPACE;
- ptr = NumberUtil.writeInt(_values[_ptr++], buffer, ptr);
- }
- return ptr;
- }
- }
-
- final static class LongArrayEncoder
- extends ArrayEncoder
- {
- final long[] _values;
-
- protected LongArrayEncoder(long[] values, int from, int length)
- {
- super(from, length);
- _values = values;
- }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- int lastOk = end - (1+NumberUtil.MAX_LONG_CLEN);
- while (ptr <= lastOk && _ptr < _end) {
- buffer[ptr++] = ' ';
- ptr = NumberUtil.writeLong(_values[_ptr++], buffer, ptr);
- }
- return ptr;
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- int lastOk = end - (1+NumberUtil.MAX_LONG_CLEN);
- while (ptr <= lastOk && _ptr < _end) {
- buffer[ptr++] = BYTE_SPACE;
- ptr = NumberUtil.writeLong(_values[_ptr++], buffer, ptr);
- }
- return ptr;
- }
- }
-
- final static class FloatArrayEncoder
- extends ArrayEncoder
- {
- final float[] _values;
-
- protected FloatArrayEncoder(float[] values, int from, int length)
- {
- super(from, length);
- _values = values;
- }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- int lastOk = end - (1+NumberUtil.MAX_FLOAT_CLEN);
- while (ptr <= lastOk && _ptr < _end) {
- buffer[ptr++] = ' ';
- ptr = NumberUtil.writeFloat(_values[_ptr++], buffer, ptr);
- }
- return ptr;
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- int lastOk = end - (1+NumberUtil.MAX_FLOAT_CLEN);
- while (ptr <= lastOk && _ptr < _end) {
- buffer[ptr++] = BYTE_SPACE;
- ptr = NumberUtil.writeFloat(_values[_ptr++], buffer, ptr);
- }
- return ptr;
- }
- }
-
- final static class DoubleArrayEncoder
- extends ArrayEncoder
- {
- final double[] _values;
-
- protected DoubleArrayEncoder(double[] values, int from, int length)
- {
- super(from, length);
- _values = values;
- }
-
- public int encodeMore(char[] buffer, int ptr, int end)
- {
- int lastOk = end - (1+NumberUtil.MAX_DOUBLE_CLEN);
- while (ptr <= lastOk && _ptr < _end) {
- buffer[ptr++] = ' ';
- ptr = NumberUtil.writeDouble(_values[_ptr++], buffer, ptr);
- }
- return ptr;
- }
-
- public int encodeMore(byte[] buffer, int ptr, int end)
- {
- int lastOk = end - (1+NumberUtil.MAX_DOUBLE_CLEN);
- while (ptr <= lastOk && _ptr < _end) {
- buffer[ptr++] = BYTE_SPACE;
- ptr = NumberUtil.writeDouble(_values[_ptr++], buffer, ptr);
- }
- return ptr;
- }
- }
-
- /*
- ////////////////////////////////////////////////////////////////
- // Implementation classes: binary (base64) encoder
- ////////////////////////////////////////////////////////////////
- */
-
- final static class Base64Encoder
- extends AsciiValueEncoder
- {
- final static char PAD_CHAR = '=';
- final static byte PAD_BYTE = (byte) PAD_CHAR;
-
- /* Hmmh. Base64 specs suggest \r\n... but for xml, \n is the
- * canonical one. Let's take xml's choice here, more compact too.
- */
- final static byte LF_CHAR = '\n';
- final static byte LF_BYTE = (byte) LF_CHAR;
-
- final Base64Variant _variant;
-
- final byte[] _input;
-
- int _inputPtr;
-
- final int _inputEnd;
-
- /**
- * We need a counter to know when to add mandatory
- * linefeed.
- */
- int _chunksBeforeLf;
-
- protected Base64Encoder(Base64Variant v, byte[] values, int from, int end)
- {
- _variant = v;
- _input = values;
- _inputPtr = from;
- _inputEnd = end;
- _chunksBeforeLf = _variant.getMaxLineLength() >> 2;
- }
-
- public boolean isCompleted() { return (_inputPtr >= _inputEnd); }
-
- public int encodeMore(char[] buffer, int outPtr, int outEnd)
- {
- // Encoding is by chunks of 3 input, 4 output chars, so:
- int inEnd = _inputEnd-3;
- // But let's also reserve room for lf char
- outEnd -= 5;
-
- while (_inputPtr <= inEnd) {
- if (outPtr > outEnd) { // no more room: need to return for flush
- return outPtr;
- }
- // First, mash 3 bytes into lsb of 32-bit int
- int b24 = ((int) _input[_inputPtr++]) << 8;
- b24 |= ((int) _input[_inputPtr++]) & 0xFF;
- b24 = (b24 << 8) | (((int) _input[_inputPtr++]) & 0xFF);
- outPtr = _variant.encodeBase64Chunk(b24, buffer, outPtr);
-
- if (--_chunksBeforeLf <= 0) {
- buffer[outPtr++] = LF_CHAR;
- _chunksBeforeLf = _variant.getMaxLineLength() >> 2;
- }
- }
- // main stuff done, any partial data to output?
- int inputLeft = (_inputEnd-_inputPtr); // 0, 1 or 2
- if (inputLeft > 0) { // yes, but do we have room for output?
- if (outPtr <= outEnd) { // yup (and we do have room for it all)
- int b24 = ((int) _input[_inputPtr++]) << 16;
- if (inputLeft == 2) {
- b24 |= (((int) _input[_inputPtr++]) & 0xFF) << 8;
- }
- outPtr = _variant.encodeBase64Partial(b24, inputLeft, buffer, outPtr);
- }
- }
- return outPtr;
- }
-
- public int encodeMore(byte[] buffer, int outPtr, int outEnd)
- {
- int inEnd = _inputEnd-3;
- outEnd -= 5;
-
- while (_inputPtr <= inEnd) {
- if (outPtr > outEnd) { // no more room: need to return for flush
- return outPtr;
- }
- // First, mash 3 bytes into lsb of 32-bit int
- int b24 = ((int) _input[_inputPtr++]) << 8;
- b24 |= ((int) _input[_inputPtr++]) & 0xFF;
- b24 = (b24 << 8) | (((int) _input[_inputPtr++]) & 0xFF);
- outPtr = _variant.encodeBase64Chunk(b24, buffer, outPtr);
-
- if (--_chunksBeforeLf <= 0) {
- buffer[outPtr++] = LF_BYTE;
- _chunksBeforeLf = _variant.getMaxLineLength() >> 2;
- }
- }
- // main stuff done, any leftovers?
- int inputLeft = (_inputEnd-_inputPtr);
- if (inputLeft > 0) { // yes, but do we have room for output?
- if (outPtr <= outEnd) { // yup
- int b24 = ((int) _input[_inputPtr++]) << 16;
- if (inputLeft == 2) {
- b24 |= (((int) _input[_inputPtr++]) & 0xFF) << 8;
- }
- outPtr = _variant.encodeBase64Partial(b24, inputLeft, buffer, outPtr);
- }
- }
- return outPtr;
- }
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/Base64Variant.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/Base64Variant.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/Base64Variant.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/Base64Variant.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,320 +0,0 @@
-/* Stax2 extension for basic Stax API (JSR-173).
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.codehaus.stax2.typed;
-
-import java.util.Arrays;
-
-/**
- * This abstract base class is used to define specific details of which
- * variant of Base64 encoding/decoding is to be used. Although there is
- * somewhat standard basic version (so-called "MIME Base64"), other variants
- * exists, see Base64 Wikipedia entry for details.
- *
- * Implementation notes:
- *
- * Note: for some output modes (when writing attributes) linefeeds may
- * need to be avoided, and this value ignored.
- */
- final int _maxLineLength;
-
- /*
- ////////////////////////////////////////////////////
- // Life-cycle
- ////////////////////////////////////////////////////
- */
-
- public Base64Variant(String name, String base64Alphabet, boolean usesPadding, char paddingChar, int maxLineLength)
- {
- _name = name;
- _usesPadding = usesPadding;
- _paddingChar = paddingChar;
- _maxLineLength = maxLineLength;
-
- // Ok and then we need to create codec tables.
-
- // First the main encoding table:
- int alphaLen = base64Alphabet.length();
- if (alphaLen != 64) {
- throw new IllegalArgumentException("Base64Alphabet length must be exactly 64 (was "+alphaLen+")");
- }
-
- // And then secondary encoding table and decoding table:
- base64Alphabet.getChars(0, alphaLen, _base64ToAsciiC, 0);
- Arrays.fill(_asciiToBase64, BASE64_VALUE_INVALID);
- for (int i = 0; i < alphaLen; ++i) {
- char alpha = _base64ToAsciiC[i];
- _base64ToAsciiB[i] = (byte) alpha;
- _asciiToBase64[alpha] = i;
- }
-
- // Plus if we use padding, add that in too
- if (usesPadding) {
- _asciiToBase64[(int) paddingChar] = BASE64_VALUE_PADDING;
- }
- }
-
- /**
- * "Copy constructor" that can be used when the base alphabet is identical
- * to one used by another variant except for the maximum line length
- * (and obviously, name).
- */
- public Base64Variant(Base64Variant base, String name, int maxLineLength)
- {
- this(base, name, base._usesPadding, base._paddingChar, maxLineLength);
- }
-
- /**
- * "Copy constructor" that can be used when the base alphabet is identical
- * to one used by another variant, but other details (padding, maximum
- * line length) differ
- */
- public Base64Variant(Base64Variant base, String name, boolean usesPadding, char paddingChar, int maxLineLength)
- {
- _name = name;
- byte[] srcB = base._base64ToAsciiB;
- System.arraycopy(srcB, 0, this._base64ToAsciiB, 0, srcB.length);
- char[] srcC = base._base64ToAsciiC;
- System.arraycopy(srcC, 0, this._base64ToAsciiC, 0, srcC.length);
- int[] srcV = base._asciiToBase64;
- System.arraycopy(srcV, 0, this._asciiToBase64, 0, srcV.length);
-
- _usesPadding = usesPadding;
- _paddingChar = paddingChar;
- _maxLineLength = maxLineLength;
- }
-
- /*
- ////////////////////////////////////////////////////
- // Public accessors
- ////////////////////////////////////////////////////
- */
-
- public String getName() { return _name; }
-
- public boolean usesPadding() { return _usesPadding; }
- public boolean usesPaddingChar(char c) { return c == _paddingChar; }
- public char getPaddingChar() { return _paddingChar; }
- public byte getPaddingByte() { return (byte)_paddingChar; }
-
- public int getMaxLineLength() { return _maxLineLength; }
-
- /*
- ////////////////////////////////////////////////////
- // Decoding support
- ////////////////////////////////////////////////////
- */
-
- /**
- * @return 6-bit decoded value, if valid character;
- */
- public int decodeBase64Char(char c)
- {
- int ch = (int) c;
- return (ch <= 127) ? _asciiToBase64[ch] : BASE64_VALUE_INVALID;
- }
-
- public int decodeBase64Byte(byte b)
- {
- int ch = (int) b;
- return (ch <= 127) ? _asciiToBase64[ch] : BASE64_VALUE_INVALID;
- }
-
- /*
- ////////////////////////////////////////////////////
- // Encoding support
- ////////////////////////////////////////////////////
- */
-
- public char encodeBase64BitsAsChar(int value)
- {
- /* Let's assume caller has done necessary checks; this
- * method must be fast and inlinable
- */
- return _base64ToAsciiC[value];
- }
-
- /**
- * Method that encodes given right-aligned (LSB) 24-bit value
- * into 4 base64 characters, stored in given result buffer.
- */
- public int encodeBase64Chunk(int b24, char[] buffer, int ptr)
- {
- buffer[ptr++] = _base64ToAsciiC[(b24 >> 18) & 0x3F];
- buffer[ptr++] = _base64ToAsciiC[(b24 >> 12) & 0x3F];
- buffer[ptr++] = _base64ToAsciiC[(b24 >> 6) & 0x3F];
- buffer[ptr++] = _base64ToAsciiC[b24 & 0x3F];
- return ptr;
- }
-
- /**
- * Method that outputs partial chunk (which only encodes one
- * or two bytes of data). Data given is still aligned same as if
- * it as full data; that is, missing data is at the "right end"
- * (LSB) of int.
- *
- * @param outputBytes Number of encoded bytes included (either 1 or 2)
- */
- public int encodeBase64Partial(int bits, int outputBytes, char[] buffer, int outPtr)
- {
- buffer[outPtr++] = _base64ToAsciiC[(bits >> 18) & 0x3F];
- buffer[outPtr++] = _base64ToAsciiC[(bits >> 12) & 0x3F];
- if (_usesPadding) {
- buffer[outPtr++] = (outputBytes == 2) ?
- _base64ToAsciiC[(bits >> 6) & 0x3F] : _paddingChar;
- buffer[outPtr++] = _paddingChar;
- } else {
- if (outputBytes == 2) {
- buffer[outPtr++] = _base64ToAsciiC[(bits >> 6) & 0x3F];
- }
- }
- return outPtr;
- }
-
- public byte encodeBase64BitsAsByte(int value)
- {
- // As with above, assuming it is 6-bit value
- return _base64ToAsciiB[value];
- }
-
- /**
- * Method that encodes given right-aligned (LSB) 24-bit value
- * into 4 base64 bytes (ascii), stored in given result buffer.
- */
- public int encodeBase64Chunk(int b24, byte[] buffer, int ptr)
- {
- buffer[ptr++] = _base64ToAsciiB[(b24 >> 18) & 0x3F];
- buffer[ptr++] = _base64ToAsciiB[(b24 >> 12) & 0x3F];
- buffer[ptr++] = _base64ToAsciiB[(b24 >> 6) & 0x3F];
- buffer[ptr++] = _base64ToAsciiB[b24 & 0x3F];
- return ptr;
- }
-
- /**
- * Method that outputs partial chunk (which only encodes one
- * or two bytes of data). Data given is still aligned same as if
- * it as full data; that is, missing data is at the "right end"
- * (LSB) of int.
- *
- * @param outputBytes Number of encoded bytes included (either 1 or 2)
- */
- public int encodeBase64Partial(int bits, int outputBytes, byte[] buffer, int outPtr)
- {
- buffer[outPtr++] = _base64ToAsciiB[(bits >> 18) & 0x3F];
- buffer[outPtr++] = _base64ToAsciiB[(bits >> 12) & 0x3F];
- if (_usesPadding) {
- byte pb = (byte) _paddingChar;
- buffer[outPtr++] = (outputBytes == 2) ?
- _base64ToAsciiB[(bits >> 6) & 0x3F] : pb;
- buffer[outPtr++] = pb;
- } else {
- if (outputBytes == 2) {
- buffer[outPtr++] = _base64ToAsciiB[(bits >> 6) & 0x3F];
- }
- }
- return outPtr;
- }
-
- /*
- ////////////////////////////////////////////////////
- // other methods
- ////////////////////////////////////////////////////
- */
-
- // @Override
- public String toString() { return _name; }
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/Base64Variants.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/Base64Variants.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/Base64Variants.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/Base64Variants.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,86 +0,0 @@
-/* Stax2 extension for basic Stax API (JSR-173).
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.codehaus.stax2.typed;
-
-/**
- * This class is used as a container for commonly used Base64 variants.
- *
- * @author Tatu Saloranta
- *
- * @since 3.0.0
- */
-public final class Base64Variants
-{
- final static String STD_BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
- /**
- * This variant is what most people would think of "the standard"
- * Base64 encoding.
- *
- * See wikipedia Base64 entry for details.
- */
- public final static Base64Variant MIME;
- static {
- MIME = new Base64Variant("MIME", STD_BASE64_ALPHABET, true, '=', 76);
- }
-
- /**
- * Slightly non-standard modification of {@link #MIME} which does not
- * use linefeeds (max line length set to infinite). Useful when linefeeds
- * wouldn't work well (possibly in attributes), or for minor space savings
- * (save 1 linefeed per 76 data chars, ie. ~1.4% savings).
- */
- public final static Base64Variant MIME_NO_LINEFEEDS;
- static {
- MIME_NO_LINEFEEDS = new Base64Variant(MIME, "MIME-NO-LINEFEEDS", Integer.MAX_VALUE);
- }
-
- /**
- * This variant is the one that predates {@link #MIME}: it is otherwise
- * identical, except that it mandates shorter line length.
- */
- public final static Base64Variant PEM = new Base64Variant(MIME, "PEM", true, '=', 64);
-
- /**
- * This non-standard variant is usually used when encoded data needs to be
- * passed via URLs (such as part of GET request). It differs from the
- * base {@link #MIME} variant in multiple ways.
- * First, no padding is used: this also means that it generally can not
- * be written in multiple separate but adjacent chunks (which would not
- * be the usual use case in any case). Also, no linefeeds are used (max
- * line length set to infinite). And finally, two characters (plus and
- * slash) that would need quoting in URLs are replaced with more
- * optimal alternatives (hyphen and underscore, respectively).
- */
- public final static Base64Variant MODIFIED_FOR_URL;
- static {
- StringBuffer sb = new StringBuffer(STD_BASE64_ALPHABET);
- // Replace plus with hyphen, slash with underscore (and no padding)
- sb.setCharAt(sb.indexOf("+"), '-');
- sb.setCharAt(sb.indexOf("/"), '_');
- /* And finally, let's not split lines either, wouldn't work too
- * well with URLs
- */
- MODIFIED_FOR_URL = new Base64Variant("MODIFIED-FOR-URL", sb.toString(), false, Base64Variant.PADDING_CHAR_NONE, Integer.MAX_VALUE);
- }
-
- /**
- * Method used to get the default variant ("MIME") for cases
- * where caller does not explicitly specify the variant
- */
- public static Base64Variant getDefaultVariant() {
- return MIME;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedArrayDecoder.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedArrayDecoder.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedArrayDecoder.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedArrayDecoder.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,35 +0,0 @@
-package org.codehaus.stax2.typed;
-
-/**
- * Base class that defines decoder used for decoding multiple
- * elements of an array type. Implementations typically use
- * an embedded instance of {@link TypedValueDecoder} for
- * decoding individual values.
- *
- * Set of concrete implementations is included in the reference
- * implementation of the Typed Access API.
- *
- * @author Tatu Saloranta
- *
- * @since 3.0
- */
-public abstract class TypedArrayDecoder
-{
- /**
- * Method called to decode single (element) value that given textual
- * input contains and store it in result array.
- *
- * @return True if decoding is complete, that is, no more
- * elements can be added to contained array
- */
- public abstract boolean decodeValue(String input) throws IllegalArgumentException;
-
- public abstract boolean decodeValue(char[] buffer, int start, int end) throws IllegalArgumentException;
-
- /**
- * @return Number of elements decoded and contained
- */
- public abstract int getCount();
-
- public abstract boolean hasRoom();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedValueDecoder.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedValueDecoder.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedValueDecoder.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedValueDecoder.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,63 +0,0 @@
-package org.codehaus.stax2.typed;
-
-/**
- * Base class that defines generic typed value decoder API used
- * by {@link TypedXMLStreamReader} to allow for efficient customized
- * decoding of textual xml content into actual typed values.
- * Set of concrete decoders is also included in the reference
- * implementation of the Typed Access API.
- *
- * Details of how value decoded is to be accessed is NOT defined
- * as part of this interface: since decoders are explicitly passed
- * by callers, they can (and need to) use more specific sub-classes
- * with value access method or methods.
- *
- * Note: to allow for optimal efficiency, there are multiple
- * decode methods, one of which gets called during decoding process.
- * This is necessary since the stream reader implementations may
- * use different internal representations, either in general (an
- * implementation might stored everyting as Strings; another
- * as character arrays).
- *
- * @author Tatu Saloranta
- *
- * @since 3.0
- */
-public abstract class TypedValueDecoder
-{
- /**
- * Method used to invoke decoding functionality, for decoding
- * the value encoded in given substring.
- * It is to try decoding value, and either store decoded value
- * for later access (using method(s) caller knows about), or
- * throw an exception to indicate problem encountered.
- *
- * Note: method will get called with "trimmed" input, i.e. input
- * will never have any leading or trailing white space.
- * It will also never be called with empty content
- * ({@link #handleEmptyValue} is called instead for such cases)
- */
- public abstract void decode(String input) throws IllegalArgumentException;
-
- /**
- * Method used to invoke decoding functionality, for decoding
- * the value encoded in given portion of character array
- * It is to try decoding value, and either store decoded value
- * for later access (using method(s) caller knows about), or
- * throw an exception to indicate problem encountered.
- *
- * Note: method will get called with "trimmed" input, i.e. input
- * will never have any leading or trailing white space.
- * It will also never be called with empty content
- * ({@link #handleEmptyValue} is called instead for such cases)
- */
- public abstract void decode(char[] buffer, int start, int end) throws IllegalArgumentException;
-
- /**
- * Method called in cases where value to decode would be empty, after
- * trimming leading and trailing white space. Decoder can
- * then either change its state (to contain value to return)
- * or throw appropriate exception
- */
- public abstract void handleEmptyValue() throws IllegalArgumentException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamException.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamException.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamException.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamException.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,118 +0,0 @@
-package org.codehaus.stax2.typed;
-
-import javax.xml.stream.Location;
-import javax.xml.stream.XMLStreamException;
-
-/**
- * This class represents an exception throw by an
- * {@link TypedXMLStreamReader} or an {@link TypedXMLStreamWriter}. It is
- * used to indicate a problems occuring when trying convert
- * data for access using typed read or write methods.
- *
- * Note that the lexical value is a mandatory thing to pass -- since
- * this exception subtype need not be used solely for wrapping
- * purposes ({@link XMLStreamException}s are to be passed as is,
- * other underlying root cause types should be unchecked), we
- * can mandate a lexical value (which may be null, however) to
- * be passed.
- * Similarly, aside from generic stream exception, it is mandated
- * that root causes to wrap need to be of type
- * {@link IllegalArgumentException}, since that is the supertype
- * of regular parsing/conversion types for primitive types.
- *
- * @since 3.0
- *
- * @author Santiago.PericasGeertsen@sun.com
- * @author Tatu Saloranta
- */
-public class TypedXMLStreamException
- extends XMLStreamException
-{
- private static final long serialVersionUID = 1L;
-
- /**
- * Lexical representation of the content that could not be
- * converted to the requested type. May be Read an element content as a boolean. The lexical
- * representation of a boolean is defined by the
- * XML Schema boolean data type. Whitespace MUST be
- * collapsed
- * according to the whiteSpace facet for the XML Schema boolean
- * data type.
- * An exception is thrown if, after whitespace is
- * collapsed, the resulting sequence of characters is not in
- * the lexical space defined by the XML Schema boolean data type.
- * (note: allowed lexical values are canonicals "true" and
- * "false", as well as non-canonical "0" and "1")
- *
- * These are the pre- and post-conditions of calling this method:
- * flush()
and close()
to the underlying
- * Writer.
- */
-public interface EscapingWriterFactory
-{
- /**
- * Method called to create an instance of escaping writer that
- * will output content using specified writer,
- * and escaping necessary characters (depending on
- * both type [attr, element text] and encoding).
- *
- * @param w Underlying writer that the encoding writer should
- * output
- * @param enc Encoding to use, as specified by the stream writer
- * (based on information application has passed)
- */
- public Writer createEscapingWriterFor(Writer w, String enc)
- throws UnsupportedEncodingException;
-
- /**
- * Method called to create an instance of escaping writer that
- * will output to the specified stream, using the specified
- * encoding,
- * and escaping necessary characters (depending on
- * both type [attr, element text] and encoding).
- *
- * @param out Underlying stream that the encoding writer should
- * output using
- * @param enc Encoding to use, as specified by the stream writer
- * (based on information application has passed)
- */
- public Writer createEscapingWriterFor(OutputStream out, String enc)
- throws UnsupportedEncodingException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2BlockResult.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2BlockResult.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2BlockResult.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2BlockResult.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,29 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-
-/**
- * This is the mid-level abstract base class for {@link Stax2Result}s
- * that an be used to write to in-memory (low-level) data structures,
- * such as byte and char arrays, StringBuffers and so forth.
- * The main reason for using such a result object (instead of constructing
- * wrapper Readers or InputStreams) is that concrete implementations
- * usually also allow more direct access to the underlying data, so
- * that stream reader implementations may be able to do more optimal
- * access.
- */
-public abstract class Stax2BlockResult
- extends Stax2Result
-{
- protected Stax2BlockResult() { }
-
- /*
- /////////////////////////////////////////
- // Public API, simple accessors/mutators
- /////////////////////////////////////////
- */
-
- public abstract Writer constructWriter() throws IOException;
-
- public abstract OutputStream constructOutputStream() throws IOException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2BlockSource.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2BlockSource.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2BlockSource.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2BlockSource.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,39 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-import java.net.URL;
-
-/**
- * This is the mid-level abstract base class for {@link Stax2Source}s
- * that an be used to access fixed-length in-memory data sources, such
- * as byte and char arrays, Strings, StringBuffers and so forth.
- * The main reason for using such a source object (instead of constructing
- * wrapper Readers or InputStreams) is that concrete implementations
- * usually also allow more direct access to the underlying data, so
- * that stream reader implementations may be able to do more optimal
- * access.
- */
-public abstract class Stax2BlockSource
- extends Stax2Source
-{
- protected Stax2BlockSource() { }
-
- /*
- /////////////////////////////////////////
- // Public API, simple accessors/mutators
- /////////////////////////////////////////
- */
-
- /**
- * Usually there is no way to refer to the underlying data source,
- * since they are in-memory data structures. Because of this, the
- * base implementation just returns null.
- */
- public URL getReference() {
- return null;
- }
-
- public abstract Reader constructReader() throws IOException;
-
- public abstract InputStream constructInputStream() throws IOException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2ByteArraySource.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2ByteArraySource.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2ByteArraySource.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2ByteArraySource.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,86 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-
-/**
- * Simple implementation of {@link Stax2BlockSource} that encapsulates
- * a byte array.
- *
- *
- */
-public abstract class Stax2Result
- implements Result
-{
- protected String mSystemId;
- protected String mPublicId;
- protected String mEncoding;
-
- protected Stax2Result() { }
-
- /*
- /////////////////////////////////////////
- // Public API, simple accessors/mutators
- /////////////////////////////////////////
- */
-
- public String getSystemId() {
- return mSystemId;
- }
-
- public void setSystemId(String id) {
- mSystemId = id;
- }
-
- public String getPublicId() {
- return mPublicId;
- }
-
- public void setPublicId(String id) {
- mPublicId = id;
- }
-
- public String getEncoding() {
- return mEncoding;
- }
-
- public void setEncoding(String enc) {
- mEncoding = enc;
- }
-
-
- /*
- ///////////////////////////////////////////
- // Public API, convenience factory methods
- ///////////////////////////////////////////
- */
-
- /**
- * This method creates a {@link Writer} via which underlying output
- * target can be written to. Note that caller is responsible for
- * closing that Writer when it is done reading it.
- */
- public abstract Writer constructWriter()
- throws IOException;
-
- /**
- * This method creates an {@link OutputStream} via which underlying output
- * target can be written to. Note that caller is responsible for
- * closing that OutputStream when it is done reading it
- */
- public abstract OutputStream constructOutputStream()
- throws IOException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2Source.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2Source.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2Source.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2Source.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,107 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.InputStream;
-import java.io.IOException;
-import java.io.Reader;
-import java.net.URL;
-
-import javax.xml.transform.Source;
-
-/**
- * This is the base class for additional input sources (implementations
- * of {@link javax.xml.transform.Source}) that Stax2
- * {@link org.codehaus.stax2.XMLInputFactory2} implementations should support.
- *
- *
- */
-public abstract class Stax2Source
- implements Source
-{
- protected String mSystemId;
- protected String mPublicId;
- protected String mEncoding;
-
- protected Stax2Source() { }
-
- /*
- /////////////////////////////////////////
- // Public API, simple accessors/mutators
- /////////////////////////////////////////
- */
-
- public String getSystemId() {
- return mSystemId;
- }
-
- public void setSystemId(String id) {
- mSystemId = id;
- }
-
- public String getPublicId() {
- return mPublicId;
- }
-
- public void setPublicId(String id) {
- mPublicId = id;
- }
-
- public String getEncoding() {
- return mEncoding;
- }
-
- public void setEncoding(String enc) {
- mEncoding = enc;
- }
-
- /**
- * @return URL that can be used to resolve references
- * originating from the content read via this source; may be
- * null if not known (which is the case for most non-referential
- * sources)
- */
- public abstract URL getReference();
-
- /*
- ///////////////////////////////////////////
- // Public API, convenience factory methods
- ///////////////////////////////////////////
- */
-
- /**
- * This method creates a {@link Reader} via which underlying input
- * source can be accessed. Note that caller is responsible for
- * closing that Reader when it is done reading it.
- */
- public abstract Reader constructReader()
- throws IOException;
-
- /**
- * This method creates an {@link InputStream} via which underlying input
- * source can be accessed. Note that caller is responsible for
- * closing that InputSource when it is done reading it
- */
- public abstract InputStream constructInputStream()
- throws IOException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2StringSource.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2StringSource.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2StringSource.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2StringSource.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,48 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-
-/**
- * Simple implementation of {@link Stax2BlockSource} that encapsulates
- * a simple {@link String}.
- */
-public class Stax2StringSource
- extends Stax2BlockSource
-{
- final String mText;
-
- public Stax2StringSource(String text) {
- mText = text;
- }
-
- /*
- /////////////////////////////////////////
- // Implementation of the Public API
- /////////////////////////////////////////
- */
-
- public Reader constructReader()
- throws IOException
- {
- return new StringReader(mText);
- }
-
- public InputStream constructInputStream()
- throws IOException
- {
- /* No obvious/easy way; if caller really wants an InputStream, it
- * can get a Reader, add an encoders, and so on.
- */
- return null;
- }
-
- /*
- /////////////////////////////////////////
- // Additional API for this source
- /////////////////////////////////////////
- */
-
- public String getText() {
- return mText;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2URLSource.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2URLSource.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/io/Stax2URLSource.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/io/Stax2URLSource.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,57 +0,0 @@
-package org.codehaus.stax2.io;
-
-import java.io.*;
-import java.net.URL;
-
-/**
- * Simple implementation of {@link Stax2ReferentialSource}, which refers
- * to the specific file.
- */
-public class Stax2URLSource
- extends Stax2ReferentialSource
-{
- final URL mURL;
-
- public Stax2URLSource(URL url) {
- mURL = url;
- }
-
- /*
- /////////////////////////////////////////
- // Public API, simple accessors/mutators
- /////////////////////////////////////////
- */
-
- /**
- * @return URL that refers to the reference resource, for the purposes
- * of resolving a relative reference from content read from the
- * resource.
- */
- public URL getReference()
- {
- return mURL;
- }
-
- public Reader constructReader()
- throws IOException
- {
- String enc = getEncoding();
- if (enc != null && enc.length() > 0) {
- return new InputStreamReader(constructInputStream(), enc);
- }
- // Sub-optimal; really shouldn't use the platform default encoding
- return new InputStreamReader(constructInputStream());
- }
-
- public InputStream constructInputStream()
- throws IOException
- {
- /* A simple optimization: if it's a file reference, can use
- * a more optimal one:
- */
- if ("file".equals(mURL.getProtocol())) {
- return new FileInputStream(mURL.getPath());
- }
- return mURL.openStream();
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/LocationInfo.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/LocationInfo.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/LocationInfo.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/LocationInfo.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,174 +0,0 @@
-package org.codehaus.stax2;
-
-import javax.xml.stream.Location;
-import javax.xml.stream.XMLStreamException;
-
-/**
- * Interface that specifies additional access methods for accessing
- * full location information of an input location within a stream reader.
- * Access interface may be directly implemented by the reader, or by
- * another (reusable or per-call-instantiated) helper object.
- *streamReader.next
, it it possible that
- * the previously accessed LocationInfo points to the old information, new
- * information, or may even contain just garbage. That is, for each new
- * event, getLocationInfo
should be called separately.
- */
-public interface LocationInfo
-{
- /*
- /////////////////////////////////////////////////////
- // Low-level extended "raw" location access methods
- /////////////////////////////////////////////////////
- */
-
- /**
- * Method that can be used to get exact byte offset (number of bytes
- * read from the stream right before getting to this location) in the
- * stream that is pointed to by this reader, right before the start
- * of the current event.
- *javax.xml.transform.dom.DOMSource
. It can however be
- * used for both full documents, and single element root fragments,
- * depending on what node is passed as the argument.
- *
- *
- */
-public abstract class DOMWrappingReader
- implements XMLStreamReader2,
- AttributeInfo, DTDInfo, LocationInfo,
- NamespaceContext,
- XMLStreamConstants
-{
- protected final static int INT_SPACE = 0x0020;
-
- // // // Bit masks used for quick type comparisons
-
- final private static int MASK_GET_TEXT =
- (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE)
- | (1 << COMMENT) | (1 << DTD) | (1 << ENTITY_REFERENCE);
-
- final private static int MASK_GET_TEXT_XXX =
- (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE) | (1 << COMMENT);
-
- final private static int MASK_GET_ELEMENT_TEXT =
- (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE)
- | (1 << ENTITY_REFERENCE);
-
- final protected static int MASK_TYPED_ACCESS_BINARY =
- (1 << START_ELEMENT) // note: END_ELEMENT handled separately
- | (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE)
- ;
-
- // // // Enumerated error case ids
-
- /**
- * Current state not START_ELEMENT, should be
- */
- protected final static int ERR_STATE_NOT_START_ELEM = 1;
-
- /**
- * Current state not START_ELEMENT or END_ELEMENT, should be
- */
- protected final static int ERR_STATE_NOT_ELEM = 2;
-
- /**
- * Current state not PROCESSING_INSTRUCTION
- */
- protected final static int ERR_STATE_NOT_PI = 3;
-
- /**
- * Current state not one where getText() can be used
- */
- protected final static int ERR_STATE_NOT_TEXTUAL = 4;
-
- /**
- * Current state not one where getTextXxx() can be used
- */
- protected final static int ERR_STATE_NOT_TEXTUAL_XXX = 5;
-
- protected final static int ERR_STATE_NOT_TEXTUAL_OR_ELEM = 6;
-
- protected final static int ERR_STATE_NO_LOCALNAME = 7;
-
- // // // Configuration:
-
- protected final String _systemId;
-
- protected final Node _rootNode;
-
- /**
- * Whether stream reader is to be namespace aware (as per property
- * {@link XMLInputFactory#IS_NAMESPACE_AWARE}) or not
- */
- protected final boolean _cfgNsAware;
-
- /**
- * Whether stream reader is to coalesce adjacent textual
- * (CHARACTERS, SPACE, CDATA) events (as per property
- * {@link XMLInputFactory#IS_COALESCING}) or not
- */
- protected final boolean _coalescing;
-
- /**
- * By default we do not force interning of names: can be
- * reset by sub-classes.
- */
- protected boolean _cfgInternNames = false;
-
- /**
- * By default we do not force interning of namespace URIs: can be
- * reset by sub-classes.
- */
- protected boolean _cfgInternNsURIs = false;
-
- // // // State:
-
- protected int _currEvent = START_DOCUMENT;
-
- /**
- * Current node is the DOM node that contains information
- * regarding the current event.
- */
- protected Node _currNode;
-
- protected int _depth = 0;
-
- /**
- * In coalescing mode, we may need to combine textual content
- * from multiple adjacent nodes. Since we shouldn't be modifying
- * the underlying DOM tree, need to accumulate it into a temporary
- * variable
- */
- protected String _coalescedText;
-
- /**
- * Helper object used for combining segments of text as needed
- */
- protected Stax2Util.TextBuffer _textBuffer = new Stax2Util.TextBuffer();
-
- // // // Attribute/namespace declaration state
-
- /* DOM, alas, does not distinguish between namespace declarations
- * and attributes (due to its roots prior to XML namespaces?).
- * Because of this, two lists need to be separated. Since this
- * information is often not needed, it will be lazily generated.
- */
-
- /**
- * Lazily instantiated List of all actual attributes for the
- * current (start) element, NOT including namespace declarations.
- * As such, elements are {@link org.w3c.dom.Attr} instances.
- *
- * Reads the content of a text-only element, an exception is thrown if
- * this is not a text-only element.
- * Regardless of value of javax.xml.stream.isCoalescing this method always
- * returns coalesced content.
- *
- */
- public String getElementText()
- throws XMLStreamException
- {
- if (_currEvent != START_ELEMENT) {
- /* Quite illogical: this is not an IllegalStateException
- * like other similar ones, but rather an XMLStreamException.
- * But that's how Stax JavaDocs outline how it should be.
- */
- reportParseProblem(ERR_STATE_NOT_START_ELEM);
- }
- // As per [WSTX-244], handling of coalescing, regular differ a lot, so:
- if (_coalescing) {
- String text = null;
- // Need to loop to get rid of PIs, comments
- while (true) {
- int type = next();
- if (type == END_ELEMENT) {
- break;
- }
- if (type == COMMENT || type == PROCESSING_INSTRUCTION) {
- continue;
- }
- if (((1 << type) & MASK_GET_ELEMENT_TEXT) == 0) {
- reportParseProblem(ERR_STATE_NOT_TEXTUAL);
- }
- if (text == null) {
- text = getText();
- } else { // uncommon but possible (with comments, PIs):
- text = text + getText();
- }
- }
- return (text == null) ? "" : text;
- }
- _textBuffer.reset();
- // Need to loop to get rid of PIs, comments
- while (true) {
- int type = next();
- if (type == END_ELEMENT) {
- break;
- }
- if (type == COMMENT || type == PROCESSING_INSTRUCTION) {
- continue;
- }
- if (((1 << type) & MASK_GET_ELEMENT_TEXT) == 0) {
- reportParseProblem(ERR_STATE_NOT_TEXTUAL);
- }
- _textBuffer.append(getText());
- }
- return _textBuffer.get();
- }
-
- /**
- * Returns type of the last event returned; or START_DOCUMENT before
- * any events has been explicitly returned.
- */
- public int getEventType()
- {
- return _currEvent;
- }
-
- public String getLocalName()
- {
- if (_currEvent == START_ELEMENT || _currEvent == END_ELEMENT) {
- return _internName(_safeGetLocalName(_currNode));
- }
- if (_currEvent != ENTITY_REFERENCE) {
- reportWrongState(ERR_STATE_NO_LOCALNAME);
- }
- return _internName(_currNode.getNodeName());
- }
-
- public final Location getLocation() {
- return getStartLocation();
- }
-
- public QName getName()
- {
- if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- return _constructQName(_currNode.getNamespaceURI(), _safeGetLocalName(_currNode), _currNode.getPrefix());
- }
-
- // // // Namespace access
-
- public NamespaceContext getNamespaceContext() {
- return this;
- }
-
- public int getNamespaceCount()
- {
- if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_ELEM);
- }
- if (_nsDeclList == null) {
- if (!_cfgNsAware) {
- return 0;
- }
- _calcNsAndAttrLists(_currEvent == START_ELEMENT);
- }
- return _nsDeclList.size() / 2;
- }
-
- /**
- * Alas, DOM does not expose any of information necessary for
- * determining actual declarations. Thus, have to indicate that
- * there are no declarations.
- */
- public String getNamespacePrefix(int index) {
- if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_ELEM);
- }
- if (_nsDeclList == null) {
- if (!_cfgNsAware) {
- handleIllegalNsIndex(index);
- }
- _calcNsAndAttrLists(_currEvent == START_ELEMENT);
- }
- if (index < 0 || (index + index) >= _nsDeclList.size()) {
- handleIllegalNsIndex(index);
- }
- // Note: _nsDeclList entries have been appropriately intern()ed if need be
- return (String) _nsDeclList.get(index + index);
- }
-
- public String getNamespaceURI() {
- if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_ELEM);
- }
- return _internNsURI(_currNode.getNamespaceURI());
- }
-
- public String getNamespaceURI(int index) {
- if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_ELEM);
- }
- if (_nsDeclList == null) {
- if (!_cfgNsAware) {
- handleIllegalNsIndex(index);
- }
- _calcNsAndAttrLists(_currEvent == START_ELEMENT);
- }
- if (index < 0 || (index + index) >= _nsDeclList.size()) {
- handleIllegalNsIndex(index);
- }
- // Note: _nsDeclList entries have been appropriately intern()ed if need be
- return (String) _nsDeclList.get(index + index + 1);
- }
-
- // Note: implemented as part of NamespaceContext
- //public String getNamespaceURI(String prefix)
-
- public String getPIData() {
- if (_currEvent != PROCESSING_INSTRUCTION) {
- reportWrongState(ERR_STATE_NOT_PI);
- }
- return _currNode.getNodeValue();
- }
-
- public String getPITarget() {
- if (_currEvent != PROCESSING_INSTRUCTION) {
- reportWrongState(ERR_STATE_NOT_PI);
- }
- return _internName(_currNode.getNodeName());
- }
-
- public String getPrefix() {
- if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_ELEM);
- }
- return _internName(_currNode.getPrefix());
- }
-
- public String getText()
- {
- if (_coalescedText != null) {
- return _coalescedText;
- }
- if (((1 << _currEvent) & MASK_GET_TEXT) == 0) {
- reportWrongState(ERR_STATE_NOT_TEXTUAL);
- }
- return _currNode.getNodeValue();
- }
-
- public char[] getTextCharacters()
- {
- String text = getText();
- return text.toCharArray();
- }
-
- public int getTextCharacters(int sourceStart, char[] target, int targetStart, int len)
- {
- if (((1 << _currEvent) & MASK_GET_TEXT_XXX) == 0) {
- reportWrongState(ERR_STATE_NOT_TEXTUAL_XXX);
- }
- String text = getText();
- if (len > text.length()) {
- len = text.length();
- }
- text.getChars(sourceStart, sourceStart+len, target, targetStart);
- return len;
- }
-
- public int getTextLength()
- {
- if (((1 << _currEvent) & MASK_GET_TEXT_XXX) == 0) {
- reportWrongState(ERR_STATE_NOT_TEXTUAL_XXX);
- }
- return getText().length();
- }
-
- public int getTextStart()
- {
- if (((1 << _currEvent) & MASK_GET_TEXT_XXX) == 0) {
- reportWrongState(ERR_STATE_NOT_TEXTUAL_XXX);
- }
- return 0;
- }
-
- public boolean hasName() {
- return (_currEvent == START_ELEMENT) || (_currEvent == END_ELEMENT);
- }
-
- public boolean hasNext() {
- return (_currEvent != END_DOCUMENT);
- }
-
- public boolean hasText() {
- return (((1 << _currEvent) & MASK_GET_TEXT) != 0);
- }
-
- public boolean isAttributeSpecified(int index)
- {
- if (_currEvent != START_ELEMENT) {
- reportWrongState(ERR_STATE_NOT_START_ELEM);
- }
- Element elem = (Element) _currNode;
- Attr attr = (Attr) elem.getAttributes().item(index);
- if (attr == null) {
- handleIllegalAttrIndex(index);
- return false;
- }
- return attr.getSpecified();
- }
-
- public boolean isCharacters()
- {
- return (_currEvent == CHARACTERS);
- }
-
- public boolean isEndElement() {
- return (_currEvent == END_ELEMENT);
- }
-
- public boolean isStartElement() {
- return (_currEvent == START_ELEMENT);
- }
-
- public boolean isWhiteSpace()
- {
- if (_currEvent == CHARACTERS || _currEvent == CDATA) {
- String text = getText();
- for (int i = 0, len = text.length(); i < len; ++i) {
- /* !!! If xml 1.1 was to be handled, should check for
- * LSEP and NEL too?
- */
- if (text.charAt(i) > INT_SPACE) {
- return false;
- }
- }
- return true;
- }
- return (_currEvent == SPACE);
- }
-
- public void require(int type, String nsUri, String localName)
- throws XMLStreamException
- {
- int curr = _currEvent;
-
- /* There are some special cases; specifically, SPACE and CDATA
- * are sometimes reported as CHARACTERS. Let's be lenient by
- * allowing both 'real' and reported types, for now.
- */
- if (curr != type) {
- if (curr == CDATA) {
- curr = CHARACTERS;
- } else if (curr == SPACE) {
- curr = CHARACTERS;
- }
- }
-
- if (type != curr) {
- throwStreamException("Required type "+Stax2Util.eventTypeDesc(type)
- +", current type "
- +Stax2Util.eventTypeDesc(curr));
- }
-
- if (localName != null) {
- if (curr != START_ELEMENT && curr != END_ELEMENT
- && curr != ENTITY_REFERENCE) {
- throwStreamException("Required a non-null local name, but current token not a START_ELEMENT, END_ELEMENT or ENTITY_REFERENCE (was "+Stax2Util.eventTypeDesc(_currEvent)+")");
- }
- String n = getLocalName();
- if (n != localName && !n.equals(localName)) {
- throwStreamException("Required local name '"+localName+"'; current local name '"+n+"'.");
- }
- }
- if (nsUri != null) {
- if (curr != START_ELEMENT && curr != END_ELEMENT) {
- throwStreamException("Required non-null NS URI, but current token not a START_ELEMENT or END_ELEMENT (was "+Stax2Util.eventTypeDesc(curr)+")");
- }
-
- String uri = getNamespaceURI();
- // No namespace?
- if (nsUri.length() == 0) {
- if (uri != null && uri.length() > 0) {
- throwStreamException("Required empty namespace, instead have '"+uri+"'.");
- }
- } else {
- if ((nsUri != uri) && !nsUri.equals(uri)) {
- throwStreamException("Required namespace '"+nsUri+"'; have '"
- +uri+"'.");
- }
- }
- }
- // Ok, fine, all's good
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamReader, iterating
- ////////////////////////////////////////////////////
- */
-
- public int next()
- throws XMLStreamException
- {
- _coalescedText = null;
-
- /* For most events, we just need to find the next sibling; and
- * that failing, close the parent element. But there are couple
- * of special cases, which are handled first:
- */
- switch (_currEvent) {
-
- case START_DOCUMENT: // initial state
- /* What to do here depends on what kind of node we started
- * with...
- */
- switch (_currNode.getNodeType()) {
- case Node.DOCUMENT_NODE:
- case Node.DOCUMENT_FRAGMENT_NODE:
- // For doc, fragment, need to find first child
- _currNode = _currNode.getFirstChild();
- // as per [WSTX-259], need to handle degenerate case of empty fragment, too
- if (_currNode == null) {
- return (_currEvent = END_DOCUMENT);
- }
- break;
-
- case Node.ELEMENT_NODE:
- // For element, curr node is fine:
- return (_currEvent = START_ELEMENT);
-
- default:
- throw new XMLStreamException("Internal error: unexpected DOM root node type "+_currNode.getNodeType()+" for node '"+_currNode+"'");
- }
- break;
-
- case END_DOCUMENT: // end reached: should not call!
- throw new java.util.NoSuchElementException("Can not call next() after receiving END_DOCUMENT");
-
- case START_ELEMENT: // element returned, need to traverse children, if any
- ++_depth;
- _attrList = null; // so it will not get reused accidentally
- {
- Node firstChild = _currNode.getFirstChild();
- if (firstChild == null) { // empty? need to return virtual END_ELEMENT
- /* Note: need not clear namespace declarations, because
- * it'll be the same as for the start elem!
- */
- return (_currEvent = END_ELEMENT);
- }
- _nsDeclList = null;
-
- /* non-empty is easy: let's just swap curr node, and
- * fall through to regular handling
- */
- _currNode = firstChild;
- break;
- }
-
- case END_ELEMENT:
-
- --_depth;
- // Need to clear these lists
- _attrList = null;
- _nsDeclList = null;
-
- /* One special case: if we hit the end of children of
- * the root element (when tree constructed with Element,
- * instead of Document or DocumentFragment). If so, it'll
- * be END_DOCUMENT:
- */
- if (_currNode == _rootNode) {
- return (_currEvent = END_DOCUMENT);
- }
- // Otherwise need to fall through to default handling:
-
- default:
- /* For anything else, we can and should just get the
- * following sibling.
- */
- {
- Node next = _currNode.getNextSibling();
- // If sibling, let's just assign and fall through
- if (next != null) {
- _currNode = next;
- break;
- }
- /* Otherwise, need to climb up _the stack and either
- * return END_ELEMENT (if parent is element) or
- * END_DOCUMENT (if not; needs to be root, then)
- */
- _currNode = _currNode.getParentNode();
- int type = _currNode.getNodeType();
- if (type == Node.ELEMENT_NODE) {
- return (_currEvent = END_ELEMENT);
- }
- // Let's do sanity check; should really be Doc/DocFragment
- if (_currNode != _rootNode ||
- (type != Node.DOCUMENT_NODE && type != Node.DOCUMENT_FRAGMENT_NODE)) {
- throw new XMLStreamException("Internal error: non-element parent node ("+type+") that is not the initial root node");
- }
- return (_currEvent = END_DOCUMENT);
- }
- }
-
- // Ok, need to determine current node type:
- switch (_currNode.getNodeType()) {
- case Node.CDATA_SECTION_NODE:
- if (_coalescing) {
- coalesceText(CDATA);
- } else {
- _currEvent = CDATA;
- }
- break;
- case Node.COMMENT_NODE:
- _currEvent = COMMENT;
- break;
- case Node.DOCUMENT_TYPE_NODE:
- _currEvent = DTD;
- break;
- case Node.ELEMENT_NODE:
- _currEvent = START_ELEMENT;
- break;
- case Node.ENTITY_REFERENCE_NODE:
- _currEvent = ENTITY_REFERENCE;
- break;
- case Node.PROCESSING_INSTRUCTION_NODE:
- _currEvent = PROCESSING_INSTRUCTION;
- break;
- case Node.TEXT_NODE:
- if (_coalescing) {
- coalesceText(CHARACTERS);
- } else {
- _currEvent = CHARACTERS;
- }
- break;
-
- // Should not get other nodes (notation/entity decl., attr)
- case Node.ATTRIBUTE_NODE:
- case Node.ENTITY_NODE:
- case Node.NOTATION_NODE:
- throw new XMLStreamException("Internal error: unexpected DOM node type "+_currNode.getNodeType()+" (attr/entity/notation?), for node '"+_currNode+"'");
-
- default:
- throw new XMLStreamException("Internal error: unrecognized DOM node type "+_currNode.getNodeType()+", for node '"+_currNode+"'");
- }
-
- return _currEvent;
- }
-
- public int nextTag()
- throws XMLStreamException
- {
- while (true) {
- int next = next();
-
- switch (next) {
- case SPACE:
- case COMMENT:
- case PROCESSING_INSTRUCTION:
- continue;
- case CDATA:
- case CHARACTERS:
- if (isWhiteSpace()) {
- continue;
- }
- throwStreamException("Received non-all-whitespace CHARACTERS or CDATA event in nextTag().");
- break; // never gets here, but jikes complains without
- case START_ELEMENT:
- case END_ELEMENT:
- return next;
- }
- throwStreamException("Received event "+Stax2Util.eventTypeDesc(next)
- +", instead of START_ELEMENT or END_ELEMENT.");
- }
- }
-
- /**
- *
Precondition: the current event is START_ELEMENT.
- *
Postcondition: the current event is the corresponding END_ELEMENT.
- *this
.
- */
- public DTDInfo getDTDInfo() throws XMLStreamException
- {
- /* Let's not allow it to be accessed during other events -- that
- * way callers won't count on it being available afterwards.
- */
- if (_currEvent != DTD) {
- return null;
- }
- return this;
- }
-
- // // // StAX2, Additional location information
-
- /**
- * Location information is always accessible, for this reader.
- */
- public final LocationInfo getLocationInfo() {
- return this;
- }
-
- // // // StAX2, Pass-through text accessors
-
-
- /**
- * Method similar to {@link #getText()}, except
- * that it just uses provided Writer to write all textual content.
- * For further optimization, it may also be allowed to do true
- * pass-through, thus possibly avoiding one temporary copy of the
- * data.
- *getText
will return
- * proper conntets. If false, reader is allowed to skip creation
- * of such copies: this can improve performance, but it also means
- * that further calls to getText
is not guaranteed to
- * return meaningful data.
- *
- * @return Number of characters written to the reader
- */
- public int getText(Writer w, boolean preserveContents)
- throws IOException, XMLStreamException
- {
- String text = getText();
- w.write(text);
- return text.length();
- }
-
- // // // StAX 2, Other accessors
-
- /**
- * @return Number of open elements in the stack; 0 when parser is in
- * prolog/epilog, 1 inside root element and so on.
- */
- public int getDepth() {
- return _depth;
- }
-
- /**
- * @return True, if cursor points to a start or end element that is
- * constructed from 'empty' element (ends with '/>');
- * false otherwise.
- */
- public boolean isEmptyElement() throws XMLStreamException
- {
- // No way to really figure it out via DOM is there?
- return false;
- }
-
- public NamespaceContext getNonTransientNamespaceContext()
- {
- /* Since DOM does not expose enough functionality to figure
- * out complete declaration stack, can not implement.
- * Can either return null, or a dummy instance. For now, let's
- * do latter:
- */
- return EmptyNamespaceContext.getInstance();
- }
-
- public String getPrefixedName()
- {
- switch (_currEvent) {
- case START_ELEMENT:
- case END_ELEMENT:
- {
- String prefix = _currNode.getPrefix();
- String ln = _safeGetLocalName(_currNode);
-
- if (prefix == null) {
- return _internName(ln);
- }
- StringBuffer sb = new StringBuffer(ln.length() + 1 + prefix.length());
- sb.append(prefix);
- sb.append(':');
- sb.append(ln);
- return _internName(sb.toString());
- }
- case ENTITY_REFERENCE:
- return getLocalName();
- case PROCESSING_INSTRUCTION:
- return getPITarget();
- case DTD:
- return getDTDRootName();
-
- }
- throw new IllegalStateException("Current state ("+Stax2Util.eventTypeDesc(_currEvent)+") not START_ELEMENT, END_ELEMENT, ENTITY_REFERENCE, PROCESSING_INSTRUCTION or DTD");
- }
-
- public void closeCompletely() throws XMLStreamException
- {
- // Nothing special to do...
- }
-
- /*
- ////////////////////////////////////////////////////
- // DTDInfo implementation (StAX 2)
- ////////////////////////////////////////////////////
- */
-
- public Object getProcessedDTD() {
- return null;
- }
-
- public String getDTDRootName() {
- if (_currEvent == DTD) {
- return _internName(((DocumentType) _currNode).getName());
- }
- return null;
- }
-
- public String getDTDPublicId() {
- if (_currEvent == DTD) {
- return ((DocumentType) _currNode).getPublicId();
- }
- return null;
- }
-
- public String getDTDSystemId() {
- if (_currEvent == DTD) {
- return ((DocumentType) _currNode).getSystemId();
- }
- return null;
- }
-
- /**
- * @return Internal subset portion of the DOCTYPE declaration, if any;
- * empty String if none
- */
- public String getDTDInternalSubset() {
- /* DOM (level 3) doesn't expose anything extra; would need to
- * synthetize subset... which would only contain some of the
- * entity and notation declarations.
- */
- return null;
- }
-
- // // StAX2, v2.0
-
- public DTDValidationSchema getProcessedDTDSchema() {
- return null;
- }
-
- /*
- ////////////////////////////////////////////////////
- // LocationInfo implementation (StAX 2)
- ////////////////////////////////////////////////////
- */
-
- // // // First, the "raw" offset accessors:
-
- public long getStartingByteOffset() {
- // !!! TBI
- return -1L;
- }
-
- public long getStartingCharOffset() {
- // !!! TBI
- return 0;
- }
-
- public long getEndingByteOffset() throws XMLStreamException
- {
- // !!! TBI
- return -1;
- }
-
- public long getEndingCharOffset() throws XMLStreamException
- {
- // !!! TBI
- return -1;
- }
-
- // // // and then the object-based access methods:
-
- public XMLStreamLocation2 getStartLocation()
- {
- return XMLStreamLocation2.NOT_AVAILABLE;
- }
-
- public XMLStreamLocation2 getCurrentLocation()
- {
- return XMLStreamLocation2.NOT_AVAILABLE;
- }
-
- public final XMLStreamLocation2 getEndLocation()
- throws XMLStreamException
- {
- return XMLStreamLocation2.NOT_AVAILABLE;
- }
-
- /*
- ////////////////////////////////////////////////////
- // Stax2 validation: !!! TODO
- ////////////////////////////////////////////////////
- */
-
- public XMLValidator validateAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- // Not implemented by the basic reader:
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- // Not implemented by the basic reader:
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidator validator)
- throws XMLStreamException
- {
- // Not implemented by the basic reader:
- return null;
- }
-
- public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
- {
- // Not implemented by the basic reader
- return null;
- }
-
- /*
- ////////////////////////////////////////////
- // Internal methods, text gathering
- ////////////////////////////////////////////
- */
-
- protected void coalesceText(int initialType)
- {
- _textBuffer.reset();
- _textBuffer.append(_currNode.getNodeValue());
-
- Node n;
- while ((n = _currNode.getNextSibling()) != null) {
- int type = n.getNodeType();
- if (type != Node.TEXT_NODE && type != Node.CDATA_SECTION_NODE) {
- break;
- }
- _currNode = n;
- _textBuffer.append(_currNode.getNodeValue());
- }
- _coalescedText = _textBuffer.get();
-
- // Either way, type gets always set to be CHARACTERS
- _currEvent = CHARACTERS;
- }
-
- /*
- ////////////////////////////////////////////
- // Internal methods, namespace support
- ////////////////////////////////////////////
- */
-
- private QName _constructQName(String uri, String ln, String prefix)
- {
- // Stupid QName impls barf on nulls...
- return new QName(_internNsURI(uri), _internName(ln), _internName(prefix));
- }
-
- /**
- * @param attrsToo Whether to include actual attributes too, or
- * just namespace declarations
- */
- private void _calcNsAndAttrLists(boolean attrsToo)
- {
- NamedNodeMap attrsIn = _currNode.getAttributes();
-
- // A common case: neither attrs nor ns decls, can use short-cut
- int len = attrsIn.getLength();
- if (len == 0) {
- _attrList = _nsDeclList = Collections.EMPTY_LIST;
- return;
- }
-
- if (!_cfgNsAware) {
- _attrList = new ArrayList(len);
- for (int i = 0; i < len; ++i) {
- _attrList.add(attrsIn.item(i));
- }
- _nsDeclList = Collections.EMPTY_LIST;
- return;
- }
-
- // most should be attributes... and possibly no ns decls:
- ArrayList attrsOut = null;
- ArrayList nsOut = null;
-
- for (int i = 0; i < len; ++i) {
- Node attr = attrsIn.item(i);
- String prefix = attr.getPrefix();
-
- // Prefix?
- if (prefix == null || prefix.length() == 0) { // nope
- // default ns decl?
- if (!"xmlns".equals(attr.getLocalName())) { // nope
- if (attrsToo) {
- if (attrsOut == null) {
- attrsOut = new ArrayList(len - i);
- }
- attrsOut.add(attr);
- }
- continue;
- }
- prefix = null;
- } else { // explicit ns decl?
- if (!"xmlns".equals(prefix)) { // nope
- if (attrsToo) {
- if (attrsOut == null) {
- attrsOut = new ArrayList(len - i);
- }
- attrsOut.add(attr);
- }
- continue;
- }
- prefix = attr.getLocalName();
- }
- if (nsOut == null) {
- nsOut = new ArrayList((len - i) * 2);
- }
- nsOut.add(_internName(prefix));
- nsOut.add(_internNsURI(attr.getNodeValue()));
- }
-
- _attrList = (attrsOut == null) ? Collections.EMPTY_LIST : attrsOut;
- _nsDeclList = (nsOut == null) ? Collections.EMPTY_LIST : nsOut;
- }
-
- private void handleIllegalAttrIndex(int index)
- {
- Element elem = (Element) _currNode;
- NamedNodeMap attrs = elem.getAttributes();
- int len = attrs.getLength();
- String msg = "Illegal attribute index "+index+"; element <"+elem.getNodeName()+"> has "+((len == 0) ? "no" : String.valueOf(len))+" attributes";
- throw new IllegalArgumentException(msg);
- }
-
- private void handleIllegalNsIndex(int index)
- {
- String msg = "Illegal namespace declaration index "+index+" (has "+getNamespaceCount()+" ns declarations)";
- throw new IllegalArgumentException(msg);
- }
-
- /**
- * Due to differences in how namespace-aware and non-namespace modes
- * work in DOM, different methods are needed. We may or may not be
- * able to detect namespace-awareness mode of the source Nodes
- * directly; but at any rate, should contain some logic for handling
- * problem cases.
- */
- private String _safeGetLocalName(Node n)
- {
- String ln = n.getLocalName();
- if (ln == null) {
- ln = n.getNodeName();
- }
- return ln;
- }
-
- /*
- ///////////////////////////////////////////////
- // Overridable error reporting methods
- ///////////////////////////////////////////////
- */
-
- protected void reportWrongState(int errorType)
- {
- throw new IllegalStateException(findErrorDesc(errorType, _currEvent));
- }
-
- protected void reportParseProblem(int errorType)
- throws XMLStreamException
- {
- throwStreamException(findErrorDesc(errorType, _currEvent));
- }
-
- protected void throwStreamException(String msg)
- throws XMLStreamException
- {
- throwStreamException(msg, getErrorLocation());
- }
-
- protected Location getErrorLocation()
- {
- Location loc = getCurrentLocation();
- if (loc == null) {
- loc = getLocation();
- }
- return loc;
- }
-
- /**
- * Method called to wrap or convert given conversion-fail exception
- * into a full {@link TypedXMLStreamException},
- *
- * @param iae Problem as reported by converter
- * @param lexicalValue Lexical value (element content, attribute value)
- * that could not be converted succesfully.
- */
- protected TypedXMLStreamException _constructTypeException(IllegalArgumentException iae, String lexicalValue)
- {
- String msg = iae.getMessage();
- if (msg == null) {
- msg = "";
- }
- Location loc = getStartLocation();
- if (loc == null) {
- return new TypedXMLStreamException(lexicalValue, msg, iae);
- }
- return new TypedXMLStreamException(lexicalValue, msg, loc);
- }
-
- protected TypedXMLStreamException _constructTypeException(String msg, String lexicalValue)
- {
- Location loc = getStartLocation();
- if (loc == null) {
- return new TypedXMLStreamException(lexicalValue, msg);
- }
- return new TypedXMLStreamException(lexicalValue, msg, loc);
- }
-
- /*
- ///////////////////////////////////////////////
- // Other internal methods
- ///////////////////////////////////////////////
- */
-
- protected ValueDecoderFactory _decoderFactory()
- {
- if (_decoderFactory == null) {
- _decoderFactory = new ValueDecoderFactory();
- }
- return _decoderFactory;
- }
-
- protected StringBase64Decoder _base64Decoder()
- {
- if (_base64Decoder == null) {
- _base64Decoder = new StringBase64Decoder();
- }
- return _base64Decoder;
- }
-
- /**
- * Method used to locate error message description to use.
- * Calls sub-classes findErrorDesc()
first, and only
- * if no message found, uses default messages defined here.
- */
- protected String findErrorDesc(int errorType, int currEvent)
- {
- String evtDesc = Stax2Util.eventTypeDesc(currEvent);
- switch (errorType) {
- case ERR_STATE_NOT_START_ELEM:
- return "Current event "+evtDesc+", needs to be START_ELEMENT";
- case ERR_STATE_NOT_ELEM:
- return "Current event "+evtDesc+", needs to be START_ELEMENT or END_ELEMENT";
- case ERR_STATE_NO_LOCALNAME:
- return "Current event ("+evtDesc+") has no local name";
- case ERR_STATE_NOT_PI:
- return "Current event ("+evtDesc+") needs to be PROCESSING_INSTRUCTION";
-
- case ERR_STATE_NOT_TEXTUAL:
- return "Current event ("+evtDesc+") not a textual event";
- case ERR_STATE_NOT_TEXTUAL_OR_ELEM:
- return "Current event ("+evtDesc+" not START_ELEMENT, END_ELEMENT, CHARACTERS or CDATA";
- case ERR_STATE_NOT_TEXTUAL_XXX:
- return "Current event "+evtDesc+", needs to be one of CHARACTERS, CDATA, SPACE or COMMENT";
- }
- // should never happen, but it'd be bad to throw another exception...
- return "Internal error (unrecognized error type: "+errorType+")";
- }
-
- /**
- * Method called to do additional intern()ing for a name, if and as
- * necessary
- */
- protected String _internName(String name)
- {
- if (name == null) {
- return "";
- }
- return _cfgInternNames ? name.intern() : name;
- }
-
- protected String _internNsURI(String uri)
- {
- if (uri == null) {
- return "";
- }
- return _cfgInternNsURIs ? uri.intern() : uri;
- }
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/dom/DOMWrappingWriter.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/dom/DOMWrappingWriter.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/dom/DOMWrappingWriter.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/dom/DOMWrappingWriter.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,684 +0,0 @@
-/* Stax2 API extension for Streaming Api for Xml processing (StAX).
- *
- * Copyright (c) 2006- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in the file LICENSE which is
- * included with the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.dom;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.text.MessageFormat;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-
-import org.w3c.dom.*;
-
-import org.codehaus.stax2.XMLStreamLocation2;
-import org.codehaus.stax2.XMLStreamReader2;
-import org.codehaus.stax2.XMLStreamWriter2;
-import org.codehaus.stax2.ri.typed.SimpleValueEncoder;
-import org.codehaus.stax2.typed.Base64Variant;
-import org.codehaus.stax2.typed.Base64Variants;
-import org.codehaus.stax2.validation.*;
-
-/**
- * This is an adapter class that partially implements {@link XMLStreamWriter}
- * as a facade on top of a DOM document or Node, allowing one
- * to basically construct DOM trees via Stax API.
- * It is meant to serve as basis for a full implementation.
- *javax.xml.transform.dom.DOMResult
. It can however be
- * used for both full documents, and single element root fragments,
- * depending on what node is passed as the argument.
- *>p>
- * One more implementation note: much code is identical to one
- * used by {@link org.codehaus.stax2.ri.Stax2WriterAdapter}.
- * Alas it is hard to reuse it without cut'n pasting.
- *
- * @author Tatu Saloranta
- *
- * @since 3.0
- */
-public abstract class DOMWrappingWriter
- implements XMLStreamWriter2
-{
- // // Constants to use as defaults for "writeStartDocument"
-
- final static String DEFAULT_OUTPUT_ENCODING = "UTF-8";
-
- final static String DEFAULT_XML_VERSION = "1.0";
-
- /*
- ////////////////////////////////////////////////////
- // Configuration
- ////////////////////////////////////////////////////
- */
-
- protected final boolean mNsAware;
-
- protected final boolean mNsRepairing;
-
- /**
- * This member variable is to keep information about encoding
- * that seems to be used for the document (or fragment) to output,
- * if known.
- */
- protected String mEncoding = null;
-
- /**
- * If we are being given info about existing bindings, it'll come
- * as a NamespaceContext.
- */
- protected NamespaceContext mNsContext;
-
- /*
- ////////////////////////////////////////////////////
- // State
- ////////////////////////////////////////////////////
- */
-
- /**
- * We need a reference to the document hosting nodes to
- * be able to create new nodes
- */
- protected final Document mDocument;
-
- /*
- ////////////////////////////////////////////////////
- // Helper objects
- ////////////////////////////////////////////////////
- */
-
- /**
- * Encoding of typed values is used the standard encoder
- * included in RI.
- */
- protected SimpleValueEncoder mValueEncoder;
-
- /*
- ////////////////////////////////////////////////////
- // Life-cycle
- ////////////////////////////////////////////////////
- */
-
- protected DOMWrappingWriter(Node treeRoot,
- boolean nsAware, boolean nsRepairing)
- throws XMLStreamException
- {
- if (treeRoot == null) {
- throw new IllegalArgumentException("Can not pass null Node for constructing a DOM-based XMLStreamWriter");
- }
- mNsAware = nsAware;
- mNsRepairing = nsRepairing;
-
- /* Ok; we need a document node; or an element node; or a document
- * fragment node.
- */
- switch (treeRoot.getNodeType()) {
- case Node.DOCUMENT_NODE: // fine
- mDocument = (Document) treeRoot;
-
- /* Should try to find encoding, version and stand-alone
- * settings... but is there a standard way of doing that?
- */
- break;
-
- case Node.ELEMENT_NODE: // can make sub-tree... ok
- mDocument = treeRoot.getOwnerDocument();
- break;
-
- case Node.DOCUMENT_FRAGMENT_NODE: // as with element...
- mDocument = treeRoot.getOwnerDocument();
- // Above types are fine
- break;
-
- default: // other Nodes not usable
- throw new XMLStreamException("Can not create an XMLStreamWriter for a DOM node of type "+treeRoot.getClass());
- }
- if (mDocument == null) {
- throw new XMLStreamException("Can not create an XMLStreamWriter for given node (of type "+treeRoot.getClass()+"): did not have owner document");
- }
- }
-
- /*
- ////////////////////////////////////////////////////
- // Partial XMLStreamWriter API (Stax 1.0) impl
- ////////////////////////////////////////////////////
- */
-
- public void close() {
- // NOP
- }
-
- public void flush() {
- // NOP
- }
-
- public abstract NamespaceContext getNamespaceContext();
- public abstract String getPrefix(String uri);
- public abstract Object getProperty(String name);
- public abstract void setDefaultNamespace(String uri);
-
- public void setNamespaceContext(NamespaceContext context) {
- mNsContext = context;
- }
-
- public abstract void setPrefix(String prefix, String uri)
- throws XMLStreamException;
-
- public abstract void writeAttribute(String localName, String value)
- throws XMLStreamException;
- public abstract void writeAttribute(String nsURI, String localName, String value)
- throws XMLStreamException;
- public abstract void writeAttribute(String prefix, String nsURI, String localName, String value)
- throws XMLStreamException;
-
- public void writeCData(String data)
- throws XMLStreamException
- {
- appendLeaf(mDocument.createCDATASection(data));
- }
-
- public void writeCharacters(char[] text, int start, int len)
- throws XMLStreamException
- {
- writeCharacters(new String(text, start, len));
- }
-
- public void writeCharacters(String text)
- throws XMLStreamException
- {
- appendLeaf(mDocument.createTextNode(text));
- }
-
- public void writeComment(String data)
- throws XMLStreamException
- {
- appendLeaf(mDocument.createCDATASection(data));
- }
-
- public abstract void writeDefaultNamespace(String nsURI)
- throws XMLStreamException;
-
- public void writeDTD(String dtd)
- throws XMLStreamException
- {
- /* Would need to parse contents, not easy to do via DOM
- * in any case.
- */
- reportUnsupported("writeDTD()");
- }
-
- public abstract void writeEmptyElement(String localName)
- throws XMLStreamException;
- public abstract void writeEmptyElement(String nsURI, String localName)
- throws XMLStreamException;
- public abstract void writeEmptyElement(String prefix, String localName, String nsURI)
- throws XMLStreamException;
-
- public abstract void writeEndDocument() throws XMLStreamException;
-
- public void writeEntityRef(String name) throws XMLStreamException
- {
- appendLeaf(mDocument.createEntityReference(name));
- }
-
- public void writeProcessingInstruction(String target)
- throws XMLStreamException
- {
- writeProcessingInstruction(target, null);
- }
-
- public void writeProcessingInstruction(String target, String data)
- throws XMLStreamException
- {
- appendLeaf(mDocument.createProcessingInstruction(target, data));
- }
-
- public void writeStartDocument()
- throws XMLStreamException
- {
- /* Note: while these defaults are not very intuitive, they
- * are what Stax 1.0 specification clearly mandates:
- */
- writeStartDocument(DEFAULT_OUTPUT_ENCODING, DEFAULT_XML_VERSION);
- }
-
- public void writeStartDocument(String version)
- throws XMLStreamException
- {
- writeStartDocument(null, version);
- }
-
- public void writeStartDocument(String encoding, String version)
- throws XMLStreamException
- {
- // Is there anything here we can or should do? No?
- mEncoding = encoding;
- }
-
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamWriter2 API (Stax2 v3.0):
- // additional accessors
- ////////////////////////////////////////////////////
- */
-
- public XMLStreamLocation2 getLocation() {
- // !!! TBI
- return null;
- }
-
- public String getEncoding() {
- return mEncoding;
- }
-
- public abstract boolean isPropertySupported(String name);
- public abstract boolean setProperty(String name, Object value);
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamWriter2 API (Stax2 v2.0):
- // extended write methods
- ////////////////////////////////////////////////////
- */
-
- public void writeCData(char[] text, int start, int len)
- throws XMLStreamException
- {
- writeCData(new String(text, start, len));
- }
-
- public abstract void writeDTD(String rootName, String systemId, String publicId,
- String internalSubset)
- throws XMLStreamException;
-
- //public void writeDTD(String rootName, String systemId, String publicId, String internalSubset)
-
- public void writeFullEndElement() throws XMLStreamException
- {
- // No difference with DOM
- writeEndElement();
- }
-
- public void writeSpace(char[] text, int start, int len)
- throws XMLStreamException
- {
- writeSpace(new String(text, start, len));
- }
-
- public void writeSpace(String text)
- throws XMLStreamException
- {
- /* This won't work all that well, given there's no way to
- * prevent quoting/escaping. But let's do what we can, since
- * the alternative (throwing an exception) doesn't seem
- * especially tempting choice.
- */
- writeCharacters(text);
- }
-
- public void writeStartDocument(String version, String encoding, boolean standAlone)
- throws XMLStreamException
- {
- writeStartDocument(encoding, version);
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamWriter2 API (Stax2 v2.0): validation
- ////////////////////////////////////////////////////
- */
-
- public XMLValidator validateAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- // !!! TBI
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- // !!! TBI
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidator validator)
- throws XMLStreamException
- {
- // !!! TBI
- return null;
- }
-
- public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
- {
- // !!! TBI
- return null;
- }
-
- /*
- ///////////////////////////////
- // Stax2, pass-through methods
- ///////////////////////////////
- */
-
- public void writeRaw(String text)
- throws XMLStreamException
- {
- reportUnsupported("writeRaw()");
- }
-
- public void writeRaw(String text, int start, int offset)
- throws XMLStreamException
- {
- reportUnsupported("writeRaw()");
- }
-
- public void writeRaw(char[] text, int offset, int length)
- throws XMLStreamException
- {
- reportUnsupported("writeRaw()");
- }
-
- public void copyEventFromReader(XMLStreamReader2 r, boolean preserveEventData)
- throws XMLStreamException
- {
- // !!! TBI
- }
-
- /*
- ///////////////////////////////
- // Stax2, output handling
- ///////////////////////////////
- */
-
- public void closeCompletely()
- {
- // NOP
- }
-
- /*
- /////////////////////////////////////////////////
- // TypedXMLStreamWriter2 implementation
- // (Typed Access API, Stax v3.0)
- /////////////////////////////////////////////////
- */
-
- // // // Typed element content write methods
-
- public void writeBoolean(boolean value) throws XMLStreamException
- {
- writeCharacters(value ? "true" : "false");
- }
-
- public void writeInt(int value) throws XMLStreamException
- {
- writeCharacters(String.valueOf(value));
- }
-
- public void writeLong(long value) throws XMLStreamException
- {
- writeCharacters(String.valueOf(value));
- }
-
- public void writeFloat(float value) throws XMLStreamException
- {
- writeCharacters(String.valueOf(value));
- }
-
- public void writeDouble(double value) throws XMLStreamException
- {
- writeCharacters(String.valueOf(value));
- }
-
- public void writeInteger(BigInteger value) throws XMLStreamException
- {
- writeCharacters(value.toString());
- }
-
- public void writeDecimal(BigDecimal value) throws XMLStreamException
- {
- writeCharacters(value.toString());
- }
-
- public void writeQName(QName name) throws XMLStreamException
- {
- writeCharacters(serializeQNameValue(name));
- }
-
- public void writeIntArray(int[] value, int from, int length)
- throws XMLStreamException
- {
- /* true -> start with space, to allow for multiple consecutive
- * to be written
- */
- writeCharacters(getValueEncoder().encodeAsString(value, from, length));
- }
-
- public void writeLongArray(long[] value, int from, int length)
- throws XMLStreamException
- {
- // true -> start with space, for multiple segments
- writeCharacters(getValueEncoder().encodeAsString(value, from, length));
- }
-
- public void writeFloatArray(float[] value, int from, int length)
- throws XMLStreamException
- {
- // true -> start with space, for multiple segments
- writeCharacters(getValueEncoder().encodeAsString(value, from, length));
- }
-
- public void writeDoubleArray(double[] value, int from, int length)
- throws XMLStreamException
- {
- // true -> start with space, for multiple segments
- writeCharacters(getValueEncoder().encodeAsString(value, from, length));
- }
-
- public void writeBinary(byte[] value, int from, int length)
- throws XMLStreamException
- {
- writeBinary(Base64Variants.getDefaultVariant(), value, from, length);
- }
-
- public void writeBinary(Base64Variant v, byte[] value, int from, int length)
- throws XMLStreamException
- {
- writeCharacters(getValueEncoder().encodeAsString(v, value, from, length));
- }
-
- // // // Typed attribute value write methods
-
- public void writeBooleanAttribute(String prefix, String nsURI, String localName, boolean value)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName, value ? "true" : "false");
- }
-
- public void writeIntAttribute(String prefix, String nsURI, String localName, int value)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName, String.valueOf(value));
- }
-
- public void writeLongAttribute(String prefix, String nsURI, String localName, long value)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName, String.valueOf(value));
- }
-
- public void writeFloatAttribute(String prefix, String nsURI, String localName, float value)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName, String.valueOf(value));
- }
-
- public void writeDoubleAttribute(String prefix, String nsURI, String localName, double value)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName, String.valueOf(value));
- }
-
- public void writeIntegerAttribute(String prefix, String nsURI, String localName, BigInteger value)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName, value.toString());
- }
-
- public void writeDecimalAttribute(String prefix, String nsURI, String localName, BigDecimal value)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName, value.toString());
- }
-
- public void writeQNameAttribute(String prefix, String nsURI, String localName, QName name)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName, serializeQNameValue(name));
- }
-
- public void writeIntArrayAttribute(String prefix, String nsURI, String localName, int[] value)
- throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(value, 0, value.length));
- }
-
- public void writeLongArrayAttribute(String prefix, String nsURI, String localName, long[] value) throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(value, 0, value.length));
- }
-
- public void writeFloatArrayAttribute(String prefix, String nsURI, String localName, float[] value) throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(value, 0, value.length));
- }
-
- public void writeDoubleArrayAttribute(String prefix, String nsURI, String localName, double[] value) throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(value, 0, value.length));
- }
-
- public void writeBinaryAttribute(String prefix, String nsURI, String localName, byte[] value) throws XMLStreamException
- {
- writeBinaryAttribute(Base64Variants.getDefaultVariant(), prefix, nsURI, localName, value);
- }
-
- public void writeBinaryAttribute(Base64Variant v, String prefix, String nsURI, String localName, byte[] value) throws XMLStreamException
- {
- writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(v, value, 0, value.length));
- }
-
-
- /*
- ////////////////////////////////////////////////////
- // Abstract methods for sub-classes to implement
- ////////////////////////////////////////////////////
- */
-
- protected abstract void appendLeaf(Node n)
- throws IllegalStateException;
-
- /*
- ////////////////////////////////////////////////////
- // Shared package methods
- ////////////////////////////////////////////////////
- */
-
- /**
- * Method called to serialize given qualified name into valid
- * String serialization, taking into account existing namespace
- * bindings.
- */
- protected String serializeQNameValue(QName name)
- throws XMLStreamException
- {
- String prefix;
- // Ok as is? In repairing mode need to ensure it's properly bound
- if (mNsRepairing) {
- String uri = name.getNamespaceURI();
- // First: let's see if a valid binding already exists:
- NamespaceContext ctxt = getNamespaceContext();
- prefix = (ctxt == null) ? null : ctxt.getPrefix(uri);
- if (prefix == null) {
- // nope: need to (try to) bind
- String origPrefix = name.getPrefix();
- if (origPrefix == null || origPrefix.length() == 0) {
- prefix = "";
- /* note: could cause a namespace conflict... but
- * there is nothing we can do with just stax1 stream
- * writer
- */
- writeDefaultNamespace(uri);
- } else {
- prefix = origPrefix;
- writeNamespace(prefix, uri);
- }
- }
- } else { // in non-repairing, good as is
- prefix = name.getPrefix();
- }
- String local = name.getLocalPart();
- if (prefix == null || prefix.length() == 0) {
- return local;
- }
-
- // Not efficient... but should be ok
- return prefix + ":" + local;
- }
-
- protected SimpleValueEncoder getValueEncoder()
- {
- if (mValueEncoder == null) {
- mValueEncoder = new SimpleValueEncoder();
- }
- return mValueEncoder;
- }
-
- /*
- ////////////////////////////////////////////////////
- // Package methods, basic output problem reporting
- ////////////////////////////////////////////////////
- */
-
- protected static void throwOutputError(String msg)
- throws XMLStreamException
- {
- throw new XMLStreamException(msg);
- }
-
- protected static void throwOutputError(String format, Object arg)
- throws XMLStreamException
- {
- String msg = MessageFormat.format(format, new Object[] { arg });
- throwOutputError(msg);
- }
-
- protected void reportUnsupported(String operName)
- {
- throw new UnsupportedOperationException(operName+" can not be used with DOM-backed writer");
- }
-}
-
-
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/EmptyIterator.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/EmptyIterator.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/EmptyIterator.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/EmptyIterator.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,31 +0,0 @@
-package org.codehaus.stax2.ri;
-
-import java.util.Iterator;
-
-/**
- * Simple implementation of "null iterator", iterator that has nothing to
- * iterate over.
- */
-public final class EmptyIterator
- implements Iterator
-{
- final static EmptyIterator sInstance = new EmptyIterator();
-
- private EmptyIterator() { }
-
- public static EmptyIterator getInstance() { return sInstance; }
-
- public boolean hasNext() { return false; }
-
- public Object next() {
- throw new java.util.NoSuchElementException();
- }
-
- public void remove()
- {
- /* The reason we do this is that we know for a fact that
- * it can not have been moved
- */
- throw new IllegalStateException();
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/EmptyNamespaceContext.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/EmptyNamespaceContext.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/EmptyNamespaceContext.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/EmptyNamespaceContext.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,81 +0,0 @@
-package org.codehaus.stax2.ri;
-
-import java.util.Iterator;
-
-import javax.xml.XMLConstants;
-import javax.xml.namespace.NamespaceContext;
-
-/**
- * Dummy {@link NamespaceContext} implementation that contains no
- * namespace information, except bindings that are specified by
- * the namespace specification itself (for prefixes "xml" and "xmlns")
- */
-public class EmptyNamespaceContext
- implements NamespaceContext
-{
- final static EmptyNamespaceContext sInstance = new EmptyNamespaceContext();
-
- private EmptyNamespaceContext() { }
-
- public static EmptyNamespaceContext getInstance() { return sInstance; }
-
- /*
- /////////////////////////////////////////////
- // NamespaceContext API
- /////////////////////////////////////////////
- */
-
- public final String getNamespaceURI(String prefix)
- {
- /* First the known offenders; invalid args, 2 predefined xml namespace
- * prefixes
- */
- if (prefix == null) {
- throw new IllegalArgumentException("Illegal to pass null/empty prefix as argument.");
- }
- if (prefix.length() > 0) {
- if (prefix.equals(XMLConstants.XML_NS_PREFIX)) {
- return XMLConstants.XML_NS_URI;
- }
- if (prefix.equals(XMLConstants.XMLNS_ATTRIBUTE)) {
- return XMLConstants.XMLNS_ATTRIBUTE_NS_URI;
- }
- }
- return null;
- }
-
- public final String getPrefix(String nsURI)
- {
- /* First the known offenders; invalid args, 2 predefined xml namespace
- * prefixes
- */
- if (nsURI == null || nsURI.length() == 0) {
- throw new IllegalArgumentException("Illegal to pass null/empty URI as argument.");
- }
- if (nsURI.equals(XMLConstants.XML_NS_URI)) {
- return XMLConstants.XML_NS_PREFIX;
- }
- if (nsURI.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) {
- return XMLConstants.XMLNS_ATTRIBUTE;
- }
- return null;
- }
-
- public final Iterator getPrefixes(String nsURI)
- {
- /* First the known offenders; invalid args, 2 predefined xml namespace
- * prefixes
- */
- if (nsURI == null || nsURI.length() == 0) {
- throw new IllegalArgumentException("Illegal to pass null/empty prefix as argument.");
- }
- if (nsURI.equals(XMLConstants.XML_NS_URI)) {
- return new SingletonIterator(XMLConstants.XML_NS_PREFIX);
- }
- if (nsURI.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) {
- return new SingletonIterator(XMLConstants.XMLNS_ATTRIBUTE);
- }
-
- return EmptyIterator.getInstance();
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/AttributeEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/AttributeEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/AttributeEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/AttributeEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,191 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-import javax.xml.stream.events.Attribute;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-
-public class AttributeEventImpl
- extends BaseEventImpl
- implements Attribute
-{
- final QName mName;
- final String mValue;
- final boolean mWasSpecified;
-
- public AttributeEventImpl(Location loc, String localName, String uri, String prefix,
- String value, boolean wasSpecified)
- {
- super(loc);
- mValue = value;
- if (prefix == null) {
- if (uri == null) {
- mName = new QName(localName);
- } else {
- mName = new QName(uri, localName);
- }
- } else {
- if (uri == null) {
- uri = ""; // only because QName will barf otherwise...
- }
- mName = new QName(uri, localName, prefix);
- }
- mWasSpecified = wasSpecified;
- }
-
- public AttributeEventImpl(Location loc, QName name, String value, boolean wasSpecified)
- {
- super(loc);
- mName = name;
- mValue = value;
- mWasSpecified = wasSpecified;
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return ATTRIBUTE;
- }
-
- public boolean isAttribute() { return true; }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- /* Specs don't really specify exactly what to output... but
- * let's do a reasonable guess:
- */
- String prefix = mName.getPrefix();
- try {
- if (prefix != null && prefix.length() > 0) {
- w.write(prefix);
- w.write(':');
- }
- w.write(mName.getLocalPart());
- w.write('=');
- w.write('"');
- writeEscapedAttrValue(w, mValue);
- w.write('"');
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- QName n = mName;
- w.writeAttribute(n.getPrefix(), n.getLocalPart(),
- n.getNamespaceURI(), mValue);
- }
-
- /*
- ///////////////////////////////////////////
- // Attribute implementation
- ///////////////////////////////////////////
- */
-
- public String getDTDType() {
- /* !!! TBI: 07-Sep-2004, TSa: Need to figure out an efficient way
- * to pass this info...
- */
- return "CDATA";
- }
-
- public QName getName()
- {
- return mName;
- }
-
- public String getValue()
- {
- return mValue;
- }
-
- public boolean isSpecified()
- {
- return mWasSpecified;
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
- if (!(o instanceof Attribute)) return false;
-
- Attribute other = (Attribute) o;
- if (mName.equals(other.getName())
- && mValue.equals(other.getValue())) {
- /* But now; do we care about compatibility of
- * DTD/Schema datatype and whether it's created
- * from attribute defaulting? Let's start by being
- * conservative and require those to match
- */
- if (isSpecified() == other.isSpecified()) {
- return stringsWithNullsEqual(getDTDType(), other.getDTDType());
- }
- }
- return false;
- }
-
- public int hashCode()
- {
- /* Hmmh. Definitely need hashCode of name; but how about
- * value? That's potentially more expensive. But, if
- * using code wants to avoid value, it should key off name
- * anyway.
- */
- return mName.hashCode() ^ mValue.hashCode();
- }
-
- /*
- ///////////////////////////////////////////
- // Internal methods
- ///////////////////////////////////////////
- */
-
- protected static void writeEscapedAttrValue(Writer w, String value)
- throws IOException
- {
- int i = 0;
- int len = value.length();
- do {
- int start = i;
- char c = '\u0000';
-
- for (; i < len; ++i) {
- c = value.charAt(i);
- if (c == '<' || c == '&' || c == '"') {
- break;
- }
- }
- int outLen = i - start;
- if (outLen > 0) {
- w.write(value, start, outLen);
- }
- if (i < len) {
- if (c == '<') {
- w.write("<");
- } else if (c == '&') {
- w.write("&");
- } else if (c == '"') {
- w.write(""");
-
- }
- }
- } while (++i < len);
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/BaseEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/BaseEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/BaseEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/BaseEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,193 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-import java.util.Iterator;
-
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-import javax.xml.stream.events.*;
-
-import org.codehaus.stax2.*;
-import org.codehaus.stax2.evt.XMLEvent2;
-
-/**
- * This abstract base class implements common functionality for
- * Stax2 reference implementation's event API part.
- *
- * @author Tatu Saloranta
- */
-public abstract class BaseEventImpl
- implements XMLEvent2
-{
- /**
- * Location where token started; exact definition may depends
- * on event type.
- */
- protected final Location mLocation;
-
- protected BaseEventImpl(Location loc)
- {
- mLocation = loc;
- }
-
- /*
- //////////////////////////////////////////////
- // Skeleton XMLEvent API
- //////////////////////////////////////////////
- */
-
- public Characters asCharacters() {
- return (Characters) this;
- }
-
- public EndElement asEndElement() {
- return (EndElement) this;
- }
-
- public StartElement asStartElement() {
- return (StartElement) this;
- }
-
- public abstract int getEventType();
-
- public Location getLocation() {
- return mLocation;
- }
-
- public QName getSchemaType() {
- return null;
- }
-
- public boolean isAttribute()
- {
- return false;
- }
-
- public boolean isCharacters()
- {
- return false;
- }
-
- public boolean isEndDocument()
- {
- return false;
- }
-
- public boolean isEndElement()
- {
- return false;
- }
-
- public boolean isEntityReference()
- {
- return false;
- }
-
- public boolean isNamespace()
- {
- return false;
- }
-
- public boolean isProcessingInstruction()
- {
- return false;
- }
-
- public boolean isStartDocument()
- {
- return false;
- }
-
- public boolean isStartElement()
- {
- return false;
- }
-
- public abstract void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException;
-
- /*
- //////////////////////////////////////////////
- // XMLEvent2 (StAX2)
- //////////////////////////////////////////////
- */
-
- public abstract void writeUsing(XMLStreamWriter2 w) throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////
- // Overridden standard methods
- ///////////////////////////////////////////
- */
-
- /**
- * Declared abstract to force redefinition by sub-classes
- */
- public abstract boolean equals(Object o);
-
- /**
- * Declared abstract to force redefinition by sub-classes
- */
- public abstract int hashCode();
-
- public String toString() {
- return "[Stax Event #"+getEventType()+"]";
- }
-
- /*
- //////////////////////////////////////////////
- // Helper methods
- //////////////////////////////////////////////
- */
-
- protected void throwFromIOE(IOException ioe)
- throws XMLStreamException
- {
- throw new XMLStreamException(ioe.getMessage(), ioe);
- }
-
- /**
- * Comparison method that will consider null Strings to be
- * equivalent to empty Strings for comparison purposes; and
- * compare equality with that caveat.
- */
- protected static boolean stringsWithNullsEqual(String s1, String s2)
- {
- if (s1 == null || s1.length() == 0) {
- return (s2 == null) || (s2.length() == 0);
- }
- return (s2 != null) && s1.equals(s2);
- }
-
- protected static boolean iteratedEquals(Iterator it1, Iterator it2)
- {
- if (it1 == null || it2 == null) { // if one is null, both have to be
- return (it1 == it2);
- }
- // Otherwise, loop-de-loop...
- while (it1.hasNext()) {
- if (!it2.hasNext()) {
- return false;
- }
- Object o1 = it1.next();
- Object o2 = it2.next();
-
- if (!o1.equals(o2)) {
- return false;
- }
- }
- return true;
- }
-
- protected static int addHash(Iterator it, int baseHash)
- {
- int hash = baseHash;
- if (it != null) {
- while (it.hasNext()) {
- hash ^= it.next().hashCode();
- }
- }
- return hash;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/CharactersEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/CharactersEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/CharactersEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/CharactersEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,221 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.Characters;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-
-public class CharactersEventImpl
- extends BaseEventImpl
- implements Characters
-{
- final String mContent;
-
- final boolean mIsCData;
- final boolean mIgnorableWS;
-
- boolean mWhitespaceChecked = false;
- boolean mIsWhitespace = false;
-
- /**
- * Constructor for regular unspecified (but non-CDATA) characters
- * event type, which may or may not be all whitespace, but is not
- * specified as ignorable white space.
- */
- public CharactersEventImpl(Location loc, String content, boolean cdata)
- {
- super(loc);
- mContent = content;
- mIsCData = cdata;
- mIgnorableWS = false;
- }
-
- /**
- * Constructor for creating white space characters...
- */
- private CharactersEventImpl(Location loc, String content,
- boolean cdata, boolean allWS, boolean ignorableWS)
- {
- super(loc);
- mContent = content;
- mIsCData = cdata;
- mIsWhitespace = allWS;
- if (allWS) {
- mWhitespaceChecked = true;
- mIgnorableWS = ignorableWS;
- } else {
- mWhitespaceChecked = false;
- mIgnorableWS = false;
- }
- }
-
- public final static CharactersEventImpl createIgnorableWS(Location loc, String content) {
- return new CharactersEventImpl(loc, content, false, true, true);
- }
-
- public final static CharactersEventImpl createNonIgnorableWS(Location loc, String content) {
- return new CharactersEventImpl(loc, content, false, true, false);
- }
-
- /*
- /////////////////////////////////////////////////////
- // Implementation of abstract base methods, overrides
- /////////////////////////////////////////////////////
- */
-
- public Characters asCharacters() { // overriden to save a cast
- return this;
- }
-
- public int getEventType() {
- return mIsCData ? CDATA : CHARACTERS;
- }
-
- public boolean isCharacters() { return true; }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- if (mIsCData) {
- w.write("");
- } else {
- writeEscapedXMLText(w, mContent);
- }
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- if (mIsCData) {
- w.writeCData(mContent);
- } else {
- w.writeCharacters(mContent);
- }
- }
-
- /*
- ///////////////////////////////////////////
- // Characters implementation
- ///////////////////////////////////////////
- */
-
- public String getData() {
- return mContent;
- }
-
- public boolean isCData() {
- return mIsCData;
- }
-
- public boolean isIgnorableWhiteSpace() {
- return mIgnorableWS;
- }
-
- public boolean isWhiteSpace() {
- // Better only do white space check, if it's done already...
- if (!mWhitespaceChecked) {
- mWhitespaceChecked = true;
- String str = mContent;
- int i = 0;
- int len = str.length();
- for (; i < len; ++i) {
- if (str.charAt(i) > 0x0020) {
- break;
- }
- }
- mIsWhitespace = (i == len);
- }
- return mIsWhitespace;
- }
-
- /*
- ///////////////////////////////////////////
- // Additional public, but non-Stax-API methods
- ///////////////////////////////////////////
- */
-
- public void setWhitespaceStatus(boolean status)
- {
- mWhitespaceChecked = true;
- mIsWhitespace = status;
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
- if (!(o instanceof Characters)) return false;
-
- Characters other = (Characters) o;
- // Obviously textual content has to match
- if (mContent.equals(other.getData())) {
- // But how about type (CDATA vs CHARACTERS)?
- // For now, let's require type match too
- return isCData() == other.isCData();
- }
- return false;
- }
-
- public int hashCode()
- {
- return mContent.hashCode();
- }
-
- /*
- ///////////////////////////////////////////
- // Internal methods
- ///////////////////////////////////////////
- */
-
- protected static void writeEscapedXMLText(Writer w, String text)
- throws IOException
- {
- final int len = text.length();
-
- int i = 0;
- while (i < len) {
- int start = i;
- char c = '\u0000';
-
- for (; i < len; ) {
- c = text.charAt(i);
- if (c == '<' || c == '&') {
- break;
- }
- if (c == '>' && i >= 2 && text.charAt(i-1) == ']'
- && text.charAt(i-2) == ']') {
- break;
- }
- ++i;
- }
- int outLen = i - start;
- if (outLen > 0) {
- w.write(text, start, outLen);
- }
- if (i < len) {
- if (c == '<') {
- w.write("<");
- } else if (c == '&') {
- w.write("&");
- } else if (c == '>') {
- w.write(">");
- }
- }
- ++i;
- }
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/CommentEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/CommentEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/CommentEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/CommentEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,75 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.Comment;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-
-public class CommentEventImpl
- extends BaseEventImpl
- implements Comment
-{
- final String mContent;
-
- public CommentEventImpl(Location loc, String content)
- {
- super(loc);
- mContent = content;
- }
-
- public String getText()
- {
- return mContent;
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return COMMENT;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- w.write("");
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- w.writeComment(mContent);
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
- if (!(o instanceof Comment)) return false;
-
- Comment other = (Comment) o;
- return mContent.equals(other.getText());
- }
-
- public int hashCode()
- {
- return mContent.hashCode();
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/DTDEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/DTDEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/DTDEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/DTDEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,255 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.StringWriter;
-import java.io.Writer;
-import java.util.*;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.DTD;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-import org.codehaus.stax2.evt.DTD2;
-
-/**
- * Vanilla implementation of a DTD event. Note that as is, it is not
- * really complete, since there is no way to access declared notations
- * and entities, because Stax 1.0 has no method for dispatching calls.
- * As such, it is expected that actual implementations would usually
- * extend this class, instead of using it as is.
- */
-public class DTDEventImpl
- extends BaseEventImpl
- implements DTD2
-{
- final String mRootName;
-
- final String mSystemId;
-
- final String mPublicId;
-
- final String mInternalSubset;
-
- final Object mDTD;
-
- /*
- /////////////////////////////////////////////////////
- // Lazily constructed objects
- /////////////////////////////////////////////////////
- */
-
- /**
- * Full textual presentation of the DOCTYPE event; usually only
- * constructed when needed, but sometimes (when using 'broken'
- * older StAX interfaces), may be the only piece that's actually
- * passed.
- */
- String mFullText = null;
-
- /*
- /////////////////////////////////////////////////////
- // Constuctors
- /////////////////////////////////////////////////////
- */
-
- public DTDEventImpl(Location loc, String rootName,
- String sysId, String pubId, String intSubset,
- Object dtd)
- {
- super(loc);
- mRootName = rootName;
- mSystemId = sysId;
- mPublicId = pubId;
- mInternalSubset = intSubset;
- mFullText = null;
- mDTD = dtd;
- }
-
- /**
- * Constructor used when only partial information is available.
- */
- public DTDEventImpl(Location loc, String rootName, String intSubset)
- {
- this(loc, rootName, null, null, intSubset, null);
- }
-
- public DTDEventImpl(Location loc, String fullText)
- {
- this(loc, null, null, null, null, null);
- mFullText = fullText;
- }
-
- /*
- /////////////////////////////////////////////////////
- // Accessors
- /////////////////////////////////////////////////////
- */
-
- public String getDocumentTypeDeclaration()
- {
- try {
- return doGetDocumentTypeDeclaration();
- } catch (XMLStreamException sex) { // should never happen
- throw new RuntimeException("Internal error: "+sex);
- }
- }
-
- public List getEntities()
- {
- // !!! TODO: create stax2 abstraction to allow accessing this
- return null;
- }
-
- public List getNotations()
- {
- // !!! TODO: create stax2 abstraction to allow accessing this
- return null;
- }
-
- public Object getProcessedDTD()
- {
- return mDTD;
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return DTD;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- // If we get 'raw' (unparsed) DOCTYPE contents, this is easy...
- if (mFullText != null) {
- w.write(mFullText);
- return;
- }
-
- w.write("");
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- if (mRootName != null) {
- w.writeDTD(mRootName, mSystemId, mPublicId, mInternalSubset);
- return;
- }
-
- // Nah, just need to do a "dumb" write...
- w.writeDTD(doGetDocumentTypeDeclaration());
- }
-
- /*
- ///////////////////////////////////////////
- // Extended interface (DTD2)
- ///////////////////////////////////////////
- */
-
- public String getRootName() {
- return mRootName;
- }
-
- public String getSystemId() {
- return mSystemId;
- }
-
- public String getPublicId() {
- return mPublicId;
- }
-
- public String getInternalSubset() {
- return mInternalSubset;
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
- if (!(o instanceof DTD)) return false;
-
- DTD other = (DTD) o;
-
- /* Hmmh. Comparison for this event get very
- * tricky, very fast, if one tries to do it correctly
- * (partly due to Stax2 incompleteness, but not just
- * because of that)... let's actually try to minimize
- * work here
- */
- return stringsWithNullsEqual(getDocumentTypeDeclaration(),
- other.getDocumentTypeDeclaration());
- }
-
-
- public int hashCode()
- {
- int hash = 0;
- if (mRootName != null) hash ^= mRootName.hashCode();
- if (mSystemId != null) hash ^= mSystemId.hashCode();
- if (mPublicId != null) hash ^= mPublicId.hashCode();
- if (mInternalSubset != null) hash ^= mInternalSubset.hashCode();
- if (mDTD != null) hash ^= mDTD.hashCode();
- if (hash == 0 && mFullText != null) {
- hash ^= mFullText.hashCode();
- }
- return hash;
- }
-
- /*
- ///////////////////////////////////////////
- // Internal methods
- ///////////////////////////////////////////
- */
-
- protected String doGetDocumentTypeDeclaration()
- throws XMLStreamException
- {
- if (mFullText == null) {
- int len = 60;
- if (mInternalSubset != null) {
- len += mInternalSubset.length() + 4;
- }
- StringWriter sw = new StringWriter(len);
- writeAsEncodedUnicode(sw);
- mFullText = sw.toString();
- }
- return mFullText;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/EndDocumentEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/EndDocumentEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/EndDocumentEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/EndDocumentEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,61 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.Writer;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.EndDocument;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-
-public class EndDocumentEventImpl
- extends BaseEventImpl
- implements EndDocument
-{
- public EndDocumentEventImpl(Location loc)
- {
- super(loc);
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return END_DOCUMENT;
- }
-
- public boolean isEndDocument() {
- return true;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- // Nothing to output
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- w.writeEndDocument();
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
- return (o instanceof EndDocument);
- }
-
- public int hashCode()
- {
- return END_DOCUMENT;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/EndElementEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/EndElementEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/EndElementEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/EndElementEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,156 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-import java.util.ArrayList;
-import java.util.Iterator;
-
-import javax.xml.namespace.QName;
-import javax.xml.stream.Location;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamReader;
-import javax.xml.stream.events.EndElement;
-import javax.xml.stream.events.Namespace;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-import org.codehaus.stax2.ri.EmptyIterator;
-import org.codehaus.stax2.ri.evt.BaseEventImpl;
-
-public class EndElementEventImpl
- extends BaseEventImpl
- implements EndElement
-{
- final QName mName;
- final ArrayList mNamespaces;
-
- /**
- * Constructor usually used when reading events from a stream reader.
- */
- public EndElementEventImpl(Location loc, XMLStreamReader r)
- {
- super(loc);
- mName = r.getName();
-
- // Let's figure out if there are any namespace declarations...
- int nsCount = r.getNamespaceCount();
- if (nsCount == 0) {
- mNamespaces = null;
- } else {
- ArrayList l = new ArrayList(nsCount);
- for (int i = 0; i < nsCount; ++i) {
- l.add(NamespaceEventImpl.constructNamespace
- (loc, r.getNamespacePrefix(i), r.getNamespaceURI(i)));
- }
- mNamespaces = l;
- }
- }
-
- /**
- * Constructor used by the event factory.
- */
- public EndElementEventImpl(Location loc, QName name, Iterator namespaces)
- {
- super(loc);
- mName = name;
- if (namespaces == null || !namespaces.hasNext()) {
- mNamespaces = null;
- } else {
- ArrayList l = new ArrayList();
- while (namespaces.hasNext()) {
- /* Let's do typecast here, to catch any cast errors early;
- * not strictly required, but helps in preventing later
- * problems
- */
- l.add((Namespace) namespaces.next());
- }
- mNamespaces = l;
- }
- }
-
- /*
- /////////////////////////////////////////////
- // Public API
- /////////////////////////////////////////////
- */
-
- public QName getName() {
- return mName;
- }
-
- public Iterator getNamespaces()
- {
- return (mNamespaces == null) ? EmptyIterator.getInstance()
- : mNamespaces.iterator();
- }
-
- /*
- /////////////////////////////////////////////////////
- // Implementation of abstract base methods, overrides
- /////////////////////////////////////////////////////
- */
-
- public EndElement asEndElement() { // overriden to save a cast
- return this;
- }
-
- public int getEventType() {
- return END_ELEMENT;
- }
-
- public boolean isEndElement() {
- return true;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- w.write("");
- String prefix = mName.getPrefix();
- if (prefix != null && prefix.length() > 0) {
- w.write(prefix);
- w.write(':');
- }
- w.write(mName.getLocalPart());
- w.write('>');
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- w.writeEndElement();
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
-
- if (!(o instanceof EndElement)) return false;
-
- EndElement other = (EndElement) o;
- // First of all, names must match obviously
- if (getName().equals(other.getName())) {
- /* But then, what about namespaces etc? For now,
- * let's actually not consider namespaces: chances
- * are corresponding START_ELEMENT must have matched
- * well enough.
- */
- return true;
- }
- return false;
- }
-
- public int hashCode()
- {
- return getName().hashCode();
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/EntityDeclarationEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/EntityDeclarationEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/EntityDeclarationEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/EntityDeclarationEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,128 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.StringWriter;
-import java.io.Writer;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.EntityDeclaration;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-
-/**
- * Simple base implementation that can be used either as a placeholder,
- * or a base for 'real' entity declaration implementations.
- */
-public class EntityDeclarationEventImpl
- extends BaseEventImpl
- implements EntityDeclaration
-{
- protected final String mName;
-
- public EntityDeclarationEventImpl(Location loc, String name)
- {
- super(loc);
- mName = name;
- }
-
- /*
- ///////////////////////////////////////////
- // EntityDeclaration
- ///////////////////////////////////////////
- */
-
- public String getBaseURI()
- {
- return "";
- }
-
- public String getName()
- {
- return mName;
- }
-
- public String getNotationName()
- {
- return null;
- }
-
- public String getPublicId()
- {
- return null;
- }
-
- public String getReplacementText()
- {
- return null;
- }
-
- public String getSystemId()
- {
- return null;
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return ENTITY_DECLARATION;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- w.write("");
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- // Really shouldn't be output. But if we must...
- StringWriter strw = new StringWriter();
- writeAsEncodedUnicode(strw);
- w.writeRaw(strw.toString());
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
-
- if (!(o instanceof EntityDeclaration)) return false;
-
- EntityDeclaration other = (EntityDeclaration) o;
- return stringsWithNullsEqual(getName(), other.getName())
- && stringsWithNullsEqual(getBaseURI(), other.getBaseURI())
- && stringsWithNullsEqual(getNotationName(), other.getNotationName())
- && stringsWithNullsEqual(getPublicId(), other.getPublicId())
- && stringsWithNullsEqual(getReplacementText(), other.getReplacementText())
- && stringsWithNullsEqual(getSystemId(), other.getSystemId())
- ;
- }
-
- public int hashCode()
- {
- // Since we don't have much data, this is easy...
- return mName.hashCode();
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/EntityReferenceEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/EntityReferenceEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/EntityReferenceEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/EntityReferenceEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,93 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.EntityReference;
-import javax.xml.stream.events.EntityDeclaration;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-
-public class EntityReferenceEventImpl
- extends BaseEventImpl
- implements EntityReference
-{
- protected final EntityDeclaration mDecl;
-
- public EntityReferenceEventImpl(Location loc, EntityDeclaration decl)
- {
- super(loc);
- mDecl = decl;
- }
-
- public EntityReferenceEventImpl(Location loc, String name)
- {
- super(loc);
- // note: location will be incorrect...
- mDecl = new EntityDeclarationEventImpl(loc, name);
- }
-
- public EntityDeclaration getDeclaration()
- {
- return mDecl;
- }
-
- public String getName()
- {
- return mDecl.getName();
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return ENTITY_REFERENCE;
- }
-
- public boolean isEntityReference() {
- return true;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- w.write('&');
- w.write(getName());
- w.write(';');
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- w.writeEntityRef(getName());
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
-
- if (!(o instanceof EntityReference)) return false;
-
- EntityReference other = (EntityReference) o;
- return getName().equals(other.getName());
- }
-
- public int hashCode()
- {
- return getName().hashCode();
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/MergedNsContext.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/MergedNsContext.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/MergedNsContext.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/MergedNsContext.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,176 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.util.*;
-
-import javax.xml.XMLConstants;
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.stream.events.Namespace;
-
-/**
- * Helper class used to combine an enclosing namespace context with
- * a list of namespace declarations contained, to result in a single
- * namespace context object.
- */
-public class MergedNsContext
- implements NamespaceContext
-{
- final NamespaceContext mParentCtxt;
-
- /**
- * List of {@link Namespace} instances.
- */
- final List mNamespaces;
-
- protected MergedNsContext(NamespaceContext parentCtxt, List localNs)
- {
- mParentCtxt = parentCtxt;
- mNamespaces = (localNs == null) ? Collections.EMPTY_LIST : localNs;
- }
-
- public static MergedNsContext construct(NamespaceContext parentCtxt,
- List localNs)
- {
- return new MergedNsContext(parentCtxt, localNs);
- }
-
- /*
- /////////////////////////////////////////////
- // NamespaceContext API
- /////////////////////////////////////////////
- */
-
- public String getNamespaceURI(String prefix)
- {
- if (prefix == null) {
- throw new IllegalArgumentException("Illegal to pass null prefix");
- }
- for (int i = 0, len = mNamespaces.size(); i < len; ++i) {
- Namespace ns = (Namespace) mNamespaces.get(i);
- if (prefix.equals(ns.getPrefix())) {
- return ns.getNamespaceURI();
- }
- }
- // Not found; how about from parent?
- if (mParentCtxt != null) {
- String uri = mParentCtxt.getNamespaceURI(prefix);
- if (uri != null) {
- return uri;
- }
- }
- if (prefix.equals(XMLConstants.XML_NS_PREFIX)) {
- return XMLConstants.XML_NS_URI;
- }
- if (prefix.equals(XMLConstants.XMLNS_ATTRIBUTE)) {
- return XMLConstants.XMLNS_ATTRIBUTE_NS_URI;
- }
- return null;
- }
-
- public String getPrefix(String nsURI)
- {
- if (nsURI == null || nsURI.length() == 0) {
- throw new IllegalArgumentException("Illegal to pass null/empty prefix as argument.");
- }
- /* Ok, first: if we can find it from within current namespaces,
- * we are golden:
- */
- for (int i = 0, len = mNamespaces.size(); i < len; ++i) {
- Namespace ns = (Namespace) mNamespaces.get(i);
- if (nsURI.equals(ns.getNamespaceURI())) {
- return ns.getPrefix();
- }
- }
- // If not, let's first try the easy way:
- if (mParentCtxt != null) {
- String prefix = mParentCtxt.getPrefix(nsURI);
- if (prefix != null) {
- // Must check for masking
- String uri2 = getNamespaceURI(prefix);
- if (uri2.equals(nsURI)) {
- // No masking, we are good:
- return prefix;
- }
- }
-
- // Otherwise, must check other candidates
- Iterator it = mParentCtxt.getPrefixes(nsURI);
- while (it.hasNext()) {
- String p2 = (String) it.next();
- if (!p2.equals(prefix)) { // no point re-checking first prefix
- // But is it masked?
- String uri2 = getNamespaceURI(p2);
- if (uri2.equals(nsURI)) {
- // No masking, we are good:
- return p2;
- }
- }
- }
- }
-
- // Ok, but how about pre-defined ones (for xml, xmlns)?
- if (nsURI.equals(XMLConstants.XML_NS_URI)) {
- return XMLConstants.XML_NS_PREFIX;
- }
- if (nsURI.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) {
- return XMLConstants.XMLNS_ATTRIBUTE;
- }
-
- // Nope, none found:
- return null;
- }
-
- public Iterator getPrefixes(String nsURI)
- {
- if (nsURI == null || nsURI.length() == 0) {
- throw new IllegalArgumentException("Illegal to pass null/empty prefix as argument.");
- }
-
- // Any local bindings?
- ArrayList l = null;
- for (int i = 0, len = mNamespaces.size(); i < len; ++i) {
- Namespace ns = (Namespace) mNamespaces.get(i);
- if (nsURI.equals(ns.getNamespaceURI())) {
- l = addToList(l, ns.getPrefix());
- }
- }
-
- // How about parent?
- if (mParentCtxt != null) {
- Iterator it = mParentCtxt.getPrefixes(nsURI);
- while (it.hasNext()) {
- String p2 = (String) it.next();
- // But is it masked?
- String uri2 = getNamespaceURI(p2);
- if (uri2.equals(nsURI)) {
- // No masking, we are good:
- l = addToList(l, p2);
- }
- }
- }
-
- // Ok, but how about pre-defined ones (for xml, xmlns)?
- if (nsURI.equals(XMLConstants.XML_NS_URI)) {
- l = addToList(l, XMLConstants.XML_NS_PREFIX);
- }
- if (nsURI.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) {
- l = addToList(l, XMLConstants.XMLNS_ATTRIBUTE);
- }
-
- return null;
- }
-
- /*
- /////////////////////////////////////////////
- // Internal methods
- /////////////////////////////////////////////
- */
-
- protected ArrayList addToList(ArrayList l, String value)
- {
- if (l == null) {
- l = new ArrayList();
- }
- l.add(value);
- return l;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/NamespaceEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/NamespaceEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/NamespaceEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/NamespaceEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,92 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import javax.xml.XMLConstants;
-import javax.xml.stream.*;
-import javax.xml.stream.events.Namespace;
-
-/**
- * Implementation of {@link Namespace}. Only returned via accessors in
- * actual "first class" event objects (start element, end element); never
- * directly via event reader.
- */
-public class NamespaceEventImpl
- extends AttributeEventImpl
- implements Namespace
-{
- final String mPrefix;
- final String mURI;
-
- /**
- * Constructor for default namespace declaration. Such declarations don't
- * have namespace prefix/URI, although semantically it would belong
- * to XML namespace URI...
- */
- protected NamespaceEventImpl(Location loc, String nsURI)
- {
- super(loc, XMLConstants.XMLNS_ATTRIBUTE, XMLConstants.XMLNS_ATTRIBUTE_NS_URI,
- null,
- nsURI, true);
- mPrefix = "";
- mURI = nsURI;
- }
-
- /**
- * Constructor for non-default namespace declaration. Such declarations
- * belong to "XML namespace" namespace.
- */
- protected NamespaceEventImpl(Location loc, String nsPrefix, String nsURI)
- {
- super(loc, nsPrefix, XMLConstants.XMLNS_ATTRIBUTE_NS_URI,
- XMLConstants.XMLNS_ATTRIBUTE,
- nsURI, true);
- mPrefix = nsPrefix;
- mURI = nsURI;
- }
-
- public static NamespaceEventImpl constructDefaultNamespace(Location loc, String nsURI)
- {
- return new NamespaceEventImpl(loc, nsURI);
- }
-
- public static NamespaceEventImpl constructNamespace(Location loc, String nsPrefix, String nsURI)
- {
- if (nsPrefix == null || nsPrefix.length() == 0) { // default NS:
- return new NamespaceEventImpl(loc, nsURI);
- }
- return new NamespaceEventImpl(loc, nsPrefix, nsURI);
- }
-
- public String getNamespaceURI() {
- return mURI;
- }
-
- public String getPrefix() {
- return mPrefix;
- }
-
- public boolean isDefaultNamespaceDeclaration() {
- return (mPrefix.length() == 0);
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return NAMESPACE;
- }
-
- public boolean isNamespace() {
- return true;
- }
-
- // Attribute's implementation for these should be ok:
-
- //public void writeAsEncodedUnicode(Writer w) throws XMLStreamException
- //public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
-
- //public boolean equals(Object o)
- //public int hashCode()
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/NotationDeclarationEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/NotationDeclarationEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/NotationDeclarationEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/NotationDeclarationEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,132 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.stream.*;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-import org.codehaus.stax2.evt.NotationDeclaration2;
-
-public class NotationDeclarationEventImpl
- extends BaseEventImpl
- implements NotationDeclaration2
-{
- /**
- * Name/id of the notation, used to reference declaration.
- */
- final String mName;
-
- final String mPublicId;
-
- final String mSystemId;
-
- public NotationDeclarationEventImpl(Location loc,
- String name, String pubId, String sysId)
- {
- super(loc);
- mName = name;
- mPublicId = pubId;
- mSystemId = sysId;
- }
-
- public String getName() {
- return mName;
- }
-
- public String getPublicId() {
- return mPublicId;
- }
-
- public String getSystemId() {
- return mSystemId;
- }
-
- /**
- * Empty base implementation: sub-classes should implement
- */
- public String getBaseURI()
- {
- return "";
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return NOTATION_DECLARATION;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- w.write("');
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- /**
- * This method does not make much sense for this event type -- the reason
- * being that the notation declarations can only be written as part of
- * a DTD (internal or external subset), not separately. Can basically
- * choose to either skip silently (output nothing), or throw an
- * exception.
- */
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- /* Fail silently, or throw an exception? Let's do latter; at least
- * then we'll get useful (?) bug reports!
- */
- throw new XMLStreamException("Can not write notation declarations using an XMLStreamWriter");
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
-
- if (!(o instanceof NotationDeclaration2)) return false;
-
- NotationDeclaration2 other = (NotationDeclaration2) o;
- // should we consider Base URI here?
- return stringsWithNullsEqual(getName(), other.getName())
- && stringsWithNullsEqual(getPublicId(), other.getPublicId())
- && stringsWithNullsEqual(getSystemId(), other.getSystemId())
- && stringsWithNullsEqual(getBaseURI(), other.getBaseURI())
- ;
- }
-
- public int hashCode()
- {
- int hash = 0;
- if (mName != null) hash ^= mName.hashCode();
- if (mPublicId != null) hash ^= mPublicId.hashCode();
- if (mSystemId != null) hash ^= mSystemId.hashCode();
- return hash;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/ProcInstrEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/ProcInstrEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/ProcInstrEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/ProcInstrEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,98 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.ProcessingInstruction;
-
-import org.codehaus.stax2.*;
-
-public class ProcInstrEventImpl
- extends BaseEventImpl
- implements ProcessingInstruction
-{
- final String mTarget;
- final String mData;
-
- public ProcInstrEventImpl(Location loc, String target, String data)
- {
- super(loc);
- mTarget = target;
- mData = data;
- }
-
- public String getData() {
- return mData;
- }
-
- public String getTarget() {
- return mTarget;
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return PROCESSING_INSTRUCTION;
- }
-
- public boolean isProcessingInstruction() {
- return true;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- w.write("");
- w.write(mTarget);
- if (mData != null && mData.length() > 0) {
- w.write(mData);
- }
- w.write("?>");
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- if (mData != null && mData.length() > 0) {
- w.writeProcessingInstruction(mTarget, mData);
- } else {
- w.writeProcessingInstruction(mTarget);
- }
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
-
- if (!(o instanceof ProcessingInstruction)) return false;
-
- ProcessingInstruction other = (ProcessingInstruction) o;
- return mTarget.equals(other.getTarget())
- && stringsWithNullsEqual(mData, other.getData());
- }
-
- public int hashCode()
- {
- int hash = mTarget.hashCode();
- if (mData != null) {
- hash ^= mData.hashCode();
- }
- return hash;
- }
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/StartDocumentEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/StartDocumentEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/StartDocumentEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/StartDocumentEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,184 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.StartDocument;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-
-public class StartDocumentEventImpl
- extends BaseEventImpl
- implements StartDocument
-{
- private final boolean mStandaloneSet;
- private final boolean mIsStandalone;
- private final String mVersion;
- private final boolean mEncodingSet;
- private final String mEncodingScheme;
- private final String mSystemId;
-
- public StartDocumentEventImpl(Location loc, XMLStreamReader r)
- {
- super(loc);
- mStandaloneSet = r.standaloneSet();
- mIsStandalone = r.isStandalone();
- /* 06-Aug-2006, TSa: Specs (class javadoc) actually specify that
- * the default should be "1.0", as opposed to stream reader that
- * should return null if no declaration exists. So, let's do
- * defaulting here if needed
- */
- {
- String version = r.getVersion();
- if (version == null || version.length() == 0) {
- version = "1.0";
- }
- mVersion = version;
- }
- mEncodingScheme = r.getCharacterEncodingScheme();
- mEncodingSet = (mEncodingScheme != null && mEncodingScheme.length() > 0);
- mSystemId = (loc != null) ? loc.getSystemId() : "";
- }
-
- /**
- * Method called by event factory, when constructing start document
- * event.
- */
- public StartDocumentEventImpl(Location loc)
- {
- this(loc, (String) null);
- }
-
- public StartDocumentEventImpl(Location loc, String encoding)
- {
- this(loc, encoding, null);
- }
-
- public StartDocumentEventImpl(Location loc, String encoding, String version)
- {
- this(loc, encoding, version, false, false);
- }
-
- public StartDocumentEventImpl(Location loc, String encoding, String version,
- boolean standaloneSet, boolean isStandalone)
- {
- super(loc);
- mEncodingScheme = encoding;
- mEncodingSet = (encoding != null && encoding.length() > 0);
- mVersion = version;
- mStandaloneSet = standaloneSet;
- mIsStandalone = isStandalone;
- mSystemId = "";
- }
-
- public boolean encodingSet() {
- return mEncodingSet;
- }
-
- public String getCharacterEncodingScheme() {
- return mEncodingScheme;
- }
-
- public String getSystemId() {
- return mSystemId;
- }
-
- public String getVersion() {
- return mVersion;
- }
-
- public boolean isStandalone() {
- return mIsStandalone;
- }
-
- public boolean standaloneSet() {
- return mStandaloneSet;
- }
-
- /*
- ///////////////////////////////////////////
- // Implementation of abstract base methods
- ///////////////////////////////////////////
- */
-
- public int getEventType() {
- return START_DOCUMENT;
- }
-
- public boolean isStartDocument() {
- return true;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- // Need to output the XML declaration?
- try {
- w.write("");
- } catch (IOException ie) {
- throwFromIOE(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException
- {
- w.writeStartDocument();
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
- if (!(o instanceof StartDocument)) return false;
-
- StartDocument other = (StartDocument) o;
-
- return (encodingSet() == other.encodingSet())
- && (isStandalone() == other.isStandalone())
- && (standaloneSet() == other.standaloneSet())
- && stringsWithNullsEqual(getCharacterEncodingScheme(), other.getCharacterEncodingScheme())
- && stringsWithNullsEqual(getSystemId(), other.getSystemId())
- && stringsWithNullsEqual(getVersion(), other.getVersion())
- ;
- }
-
-
- public int hashCode()
- {
- int hash = 0;
-
- if (encodingSet()) ++hash;
- if (isStandalone()) --hash;
- if (standaloneSet()) hash ^= 1;
- if (mVersion != null) hash ^= mVersion.hashCode();
- if (mEncodingScheme != null) hash ^= mEncodingScheme.hashCode();
- if (mSystemId != null) hash ^= mSystemId.hashCode();
- return hash;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/StartElementEventImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/StartElementEventImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/StartElementEventImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/StartElementEventImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,302 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.io.IOException;
-import java.io.Writer;
-import java.util.*;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-import javax.xml.stream.events.Attribute;
-import javax.xml.stream.events.Namespace;
-import javax.xml.stream.events.StartElement;
-
-import org.codehaus.stax2.XMLStreamWriter2;
-import org.codehaus.stax2.ri.EmptyIterator;
-import org.codehaus.stax2.ri.EmptyNamespaceContext;
-
-/**
- * Wstx {@link StartElement} implementation used when event is constructed
- * from already objectified data, for example when constructed by the event
- * factory.
- */
-public class StartElementEventImpl
- extends BaseEventImpl
- implements StartElement
-{
- // // // Basic configuration
-
- protected final QName mName;
-
- protected final ArrayList mAttrs;
-
- protected final ArrayList mNsDecls;
-
- /**
- * Enclosing namespace context
- */
- protected NamespaceContext mParentNsCtxt;
-
- // // // Lazily constructed components
-
- NamespaceContext mActualNsCtxt = null;
-
- /*
- /////////////////////////////////////////////
- // Life cycle
- /////////////////////////////////////////////
- */
-
- protected StartElementEventImpl(Location loc, QName name,
- ArrayList attrs, ArrayList nsDecls,
- NamespaceContext parentNsCtxt)
- {
- super(loc);
- mName = name;
- mAttrs = attrs;
- mNsDecls = nsDecls;
- mParentNsCtxt = (parentNsCtxt == null) ?
- EmptyNamespaceContext.getInstance() : parentNsCtxt;
- }
-
- public static StartElementEventImpl construct(Location loc, QName name,
- Iterator attrIt, Iterator nsDeclIt,
- NamespaceContext nsCtxt)
- {
- ArrayList attrs;
- if (attrIt == null || !attrIt.hasNext()) {
- attrs = null;
- } else {
- attrs = new ArrayList();
- do {
- // Cast is only done for early catching of incorrect types
- attrs.add((Attribute) attrIt.next());
- } while (attrIt.hasNext());
- }
-
- ArrayList nsDecls;
- if (nsDeclIt == null || !nsDeclIt.hasNext()) {
- nsDecls = null;
- } else {
- nsDecls = new ArrayList();
- do {
- nsDecls.add((Namespace) nsDeclIt.next()); // cast to catch type problems early
- } while (nsDeclIt.hasNext());
- }
- return new StartElementEventImpl(loc, name, attrs, nsDecls, nsCtxt);
- }
-
- /*
- /////////////////////////////////////////////////////
- // Implementation of abstract base methods, overrides
- /////////////////////////////////////////////////////
- */
-
- public StartElement asStartElement() { // overriden to save a cast
- return this;
- }
-
- public int getEventType() {
- return START_ELEMENT;
- }
-
- public boolean isStartElement() {
- return true;
- }
-
- public void writeAsEncodedUnicode(Writer w)
- throws XMLStreamException
- {
- try {
- w.write('<');
- String prefix = mName.getPrefix();
- if (prefix != null && prefix.length() > 0) {
- w.write(prefix);
- w.write(':');
- }
- w.write(mName.getLocalPart());
-
- // Any namespaces?
- if (mNsDecls != null) {
- for (int i = 0, len = mNsDecls.size(); i < len; ++i) {
- w.write(' ');
- ((Namespace) mNsDecls.get(i)).writeAsEncodedUnicode(w);
- }
- }
-
- // How about attrs?
- if (mAttrs != null) {
- for (int i = 0, len = mAttrs.size(); i < len; ++i) {
- Attribute attr = (Attribute) mAttrs.get(i);
- // No point in adding default attributes?
- if (attr.isSpecified()) {
- w.write(' ');
- attr.writeAsEncodedUnicode(w);
- }
- }
- }
-
- w.write('>');
- } catch (IOException ie) {
- throw new XMLStreamException(ie);
- }
- }
-
- public void writeUsing(XMLStreamWriter2 sw) throws XMLStreamException
- {
- QName n = mName;
- sw.writeStartElement(n.getPrefix(), n.getLocalPart(),
- n.getNamespaceURI());
-
- // Any namespaces?
- if (mNsDecls != null) {
- for (int i = 0, len = mNsDecls.size(); i < len; ++i) {
- Namespace ns = (Namespace) mNsDecls.get(i);
- String prefix = ns.getPrefix();
- String uri = ns.getNamespaceURI();
- if (prefix == null || prefix.length() == 0) {
- sw.writeDefaultNamespace(uri);
- } else {
- sw.writeNamespace(prefix, uri);
- }
- }
- }
-
- // How about attrs?
- if (mAttrs != null) {
- for (int i = 0, len = mAttrs.size(); i < len; ++i) {
- Attribute attr = (Attribute) mAttrs.get(i);
- // No point in adding default attributes?
- if (attr.isSpecified()) {
- QName name = attr.getName();
- sw.writeAttribute(name.getPrefix(), name.getNamespaceURI(), name.getLocalPart(), attr.getValue());
- }
- }
- }
- }
-
- /*
- /////////////////////////////////////////////
- // Public API
- /////////////////////////////////////////////
- */
-
- public final QName getName() {
- return mName;
- }
-
- public Iterator getNamespaces()
- {
- return (mNsDecls == null) ?
- EmptyIterator.getInstance() : mNsDecls.iterator();
- }
-
- public NamespaceContext getNamespaceContext()
- {
- if (mActualNsCtxt == null) {
- if (mNsDecls == null) {
- mActualNsCtxt = mParentNsCtxt;
- } else {
- mActualNsCtxt = MergedNsContext.construct(mParentNsCtxt, mNsDecls);
- }
- }
- return mActualNsCtxt;
- }
-
- public String getNamespaceURI(String prefix)
- {
- if (mNsDecls != null) {
- if (prefix == null) {
- prefix = "";
- }
- for (int i = 0, len = mNsDecls.size(); i < len; ++i) {
- Namespace ns = (Namespace) mNsDecls.get(i);
- String thisPrefix = ns.getPrefix();
- if (thisPrefix == null) {
- thisPrefix = "";
- }
- if (prefix.equals(thisPrefix)) {
- return ns.getNamespaceURI();
- }
- }
- }
-
- return null;
- }
-
- public Attribute getAttributeByName(QName nameIn)
- {
- if (mAttrs == null) {
- return null;
- }
-
- String ln = nameIn.getLocalPart();
- String uri = nameIn.getNamespaceURI();
- int len = mAttrs.size();
-
- boolean notInNs = (uri == null || uri.length() == 0);
- for (int i = 0; i < len; ++i) {
- Attribute attr = (Attribute) mAttrs.get(i);
- QName name = attr.getName();
- if (name.getLocalPart().equals(ln)) {
- String thisUri = name.getNamespaceURI();
- if (notInNs) {
- if (thisUri == null || thisUri.length() == 0) {
- return attr;
- }
- } else {
- if (uri.equals(thisUri)) {
- return attr;
- }
- }
- }
- }
- return null;
- }
-
- public Iterator getAttributes()
- {
- if (mAttrs == null) {
- return EmptyIterator.getInstance();
- }
- return mAttrs.iterator();
- }
-
- /*
- ///////////////////////////////////////////
- // Standard method impl
- ///////////////////////////////////////////
- */
-
- public boolean equals(Object o)
- {
- if (o == this) return true;
- if (o == null) return false;
-
- if (!(o instanceof StartElement)) return false;
-
- StartElement other = (StartElement) o;
-
- // First things first: names must match
- if (mName.equals(other.getName())) {
- /* Rest is much trickier. I guess the easiest way is to
- * just blindly iterate through ns decls and attributes.
- * The main issue is whether ordering should matter; it will,
- * if just iterating. Would need to sort to get canonical
- * comparison.
- */
- if (iteratedEquals(getNamespaces(), other.getNamespaces())) {
- return iteratedEquals(getAttributes(), other.getAttributes());
- }
- }
- return false;
- }
-
- public int hashCode()
- {
- int hash = mName.hashCode();
- hash = addHash(getNamespaces(), hash);
- hash = addHash(getAttributes(), hash);
- return hash;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/Stax2EventAllocatorImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/Stax2EventAllocatorImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/Stax2EventAllocatorImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/Stax2EventAllocatorImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,193 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import java.util.*;
-
-import javax.xml.namespace.QName;
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.stream.*;
-import javax.xml.stream.events.DTD;
-import javax.xml.stream.events.EntityReference;
-import javax.xml.stream.events.StartElement;
-import javax.xml.stream.events.XMLEvent;
-import javax.xml.stream.util.XMLEventAllocator;
-import javax.xml.stream.util.XMLEventConsumer;
-
-import org.codehaus.stax2.*;
-import org.codehaus.stax2.ri.EmptyIterator;
-
-/**
- * Base implementation of {@link XMLEventAllocator}, to be
- * used either as is, or as a base for more specialized Stax2
- * event allocator implementation.
- */
-public class Stax2EventAllocatorImpl
- implements XMLEventAllocator, XMLStreamConstants
-{
- public Stax2EventAllocatorImpl() { }
-
- /*
- //////////////////////////////////////////////////////////
- // XMLEventAllocator implementation
- //////////////////////////////////////////////////////////
- */
-
- public XMLEvent allocate(XMLStreamReader r)
- throws XMLStreamException
- {
- Location loc = getLocation(r);
-
- switch (r.getEventType()) {
- case CDATA:
- return new CharactersEventImpl(loc, r.getText(), true);
- case CHARACTERS:
- return new CharactersEventImpl(loc, r.getText(), false);
- case COMMENT:
- return new CommentEventImpl(loc, r.getText());
- case DTD:
- return createDTD(r, loc);
-
- case END_DOCUMENT:
- return new EndDocumentEventImpl(loc);
-
- case END_ELEMENT:
- return new EndElementEventImpl(loc, r);
-
- case PROCESSING_INSTRUCTION:
- return new ProcInstrEventImpl(loc, r.getPITarget(), r.getPIData());
- case SPACE:
- {
- CharactersEventImpl ch = new CharactersEventImpl(loc, r.getText(), false);
- ch.setWhitespaceStatus(true);
- return ch;
- }
- case START_DOCUMENT:
- return new StartDocumentEventImpl(loc, r);
-
- case START_ELEMENT:
- return createStartElement(r, loc);
-
- case ENTITY_REFERENCE:
- return createEntityReference(r, loc);
-
- /* Following 2 types should never get in here; they are directly
- * handled by DTDReader, and can only be accessed via DTD event
- * element.
- */
- case ENTITY_DECLARATION:
- case NOTATION_DECLARATION:
- /* Following 2 types should never get in here; they are directly
- * handled by the reader, and can only be accessed via start
- * element.
- */
- case NAMESPACE:
- case ATTRIBUTE:
- default:
- throw new XMLStreamException("Unrecognized event type "+r.getEventType()+".");
- }
- }
-
- public void allocate(XMLStreamReader r, XMLEventConsumer consumer)
- throws XMLStreamException
- {
- consumer.add(allocate(r));
- }
-
- public XMLEventAllocator newInstance() {
- return new Stax2EventAllocatorImpl();
- }
-
- /*
- //////////////////////////////////////////////////////////
- // Overridable methods
- //////////////////////////////////////////////////////////
- */
-
- /**
- * Method used to get the {@link Location} object to use for
- * an event to create. Base implementation just calls stream
- * reader's accessors, but sub-classes may choose to use other
- * methods (esp. when not in "preserve location" mode).
- */
- protected Location getLocation(XMLStreamReader r)
- {
- return r.getLocation();
- }
-
- protected EntityReference createEntityReference(XMLStreamReader r, Location loc)
- throws XMLStreamException
- {
- /* !!! 28-Jan-2007, TSA: One major problem here: there is no way
- * to access actual entity declaration via Stax 1.0 or Stax2
- * stream reader, at not least not after DTD subset has been
- * processed. But let's do our best, which means we only know
- * the name.
- */
- return new EntityReferenceEventImpl(loc, r.getLocalName());
- }
-
- protected DTD createDTD(XMLStreamReader r, Location loc)
- throws XMLStreamException
- {
- // Not sure if we really need this defensive coding but...
- if (r instanceof XMLStreamReader2) {
- XMLStreamReader2 sr2 = (XMLStreamReader2) r;
- DTDInfo dtd = sr2.getDTDInfo();
- return new DTDEventImpl
- (loc,
- dtd.getDTDRootName(),
- dtd.getDTDSystemId(), dtd.getDTDPublicId(),
- dtd.getDTDInternalSubset(),
- dtd.getProcessedDTD());
- }
- /* No way to get all information... the real big problem is
- * that of how to access root name: it's obligatory for
- * DOCTYPE construct. :-/
- */
- return new DTDEventImpl(loc, null, r.getText());
- }
-
- protected StartElement createStartElement(XMLStreamReader r, Location loc)
- throws XMLStreamException
- {
- NamespaceContext nsCtxt = null;
- /* Note: there's no way to get non-transient namespace context via
- * Stax 1.0 interface -- the context you can access from reader
- * remains stable only during current event.
- */
- if (r instanceof XMLStreamReader2) {
- nsCtxt = ((XMLStreamReader2) r).getNonTransientNamespaceContext();
- }
-
- List attrs;
- {
- int attrCount = r.getAttributeCount();
- if (attrCount < 1) {
- attrs = null;
- } else {
- attrs = new ArrayList(attrCount);
- for (int i = 0; i < attrCount; ++i) {
- QName aname = r.getAttributeName(i);
- attrs.add(new AttributeEventImpl(loc, aname, r.getAttributeValue(i), r.isAttributeSpecified(i)));
- }
- }
- }
- List ns;
- {
- int nsCount = r.getNamespaceCount();
- if (nsCount < 1) {
- ns = null;
- } else {
- ns = new ArrayList(nsCount);
- for (int i = 0; i < nsCount; ++i) {
- ns.add(NamespaceEventImpl.constructNamespace(loc, r.getNamespacePrefix(i), r.getNamespaceURI(i)));
- }
- }
- }
-
- return StartElementEventImpl.construct
- (loc, r.getName(),
- ((attrs == null) ? EmptyIterator.getInstance() : attrs.iterator()),
- ((ns == null) ? EmptyIterator.getInstance() : ns.iterator()),
- nsCtxt);
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/Stax2EventReaderAdapter.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/Stax2EventReaderAdapter.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/Stax2EventReaderAdapter.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/Stax2EventReaderAdapter.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,135 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.*;
-
-import org.codehaus.stax2.XMLEventReader2;
-
-/**
- * This adapter implements parts of {@link XMLEventReader2}, the
- * extended stream reader defined by Stax2 extension, by wrapping
- * a vanilla Stax 1.0 {@link XMLEventReader} implementation.
- *
- *
- *
- * @author Tatu Saloranta
- */
-public class Stax2EventReaderAdapter
- implements XMLEventReader2
-{
- final XMLEventReader mReader;
-
- /*
- ////////////////////////////////////////////////////
- // Life-cycle methods
- ////////////////////////////////////////////////////
- */
-
- protected Stax2EventReaderAdapter(XMLEventReader er)
- {
- mReader = er;
- }
-
- /**
- * Method that should be used to add dynamic support for
- * {@link XMLEventReader2}. Method will check whether the
- * stream reader passed happens to be a {@link XMLEventReader2};
- * and if it is, return it properly cast. If not, it will create
- * necessary wrapper.
- */
- public static XMLEventReader2 wrapIfNecessary(XMLEventReader er)
- {
- if (er instanceof XMLEventReader2) {
- return (XMLEventReader2) er;
- }
- return new Stax2EventReaderAdapter(er);
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLEventReader pass-through methods
- ////////////////////////////////////////////////////
- */
-
- public void close() throws XMLStreamException {
- mReader.close();
- }
-
- public String getElementText() throws XMLStreamException {
- return mReader.getElementText();
- }
-
- public Object getProperty(String name) {
- return mReader.getProperty(name);
- }
-
- public boolean hasNext() {
- return mReader.hasNext();
- }
-
- public XMLEvent nextEvent() throws XMLStreamException
- {
- return mReader.nextEvent();
- }
-
- public Object next() {
- return mReader.next();
- }
-
- public XMLEvent nextTag() throws XMLStreamException {
- return mReader.nextTag();
- }
-
- public XMLEvent peek() throws XMLStreamException {
- return mReader.peek();
- }
-
- /**
- * Note: only here because we implement Iterator interface.
- */
- public void remove() {
- mReader.remove();
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLEventReader2 implementation
- ////////////////////////////////////////////////////
- */
-
- public boolean hasNextEvent() throws XMLStreamException
- {
- return (peek() != null);
- }
-
- public boolean isPropertySupported(String name)
- {
- /* No way to support properly via Stax1 interface... but
- * let's approximate: we can be sure it is supported, if
- * we can access value without IllegalArgumentException
- */
- try {
- /*Object x =*/ mReader.getProperty(name);
- } catch (IllegalArgumentException iae) {
- return false;
- }
- return true;
- }
-
- public boolean setProperty(String name, Object value)
- {
- // No way to support via Stax1 interface
- return false;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/Stax2FilteredEventReader.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/Stax2FilteredEventReader.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/evt/Stax2FilteredEventReader.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/evt/Stax2FilteredEventReader.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,142 +0,0 @@
-package org.codehaus.stax2.ri.evt;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.*;
-
-import org.codehaus.stax2.XMLEventReader2;
-
-/**
- *
- *
- */
-public class Stax2FilteredEventReader
- implements XMLEventReader2,
- XMLStreamConstants
-{
- final XMLEventReader2 mReader;
- final EventFilter mFilter;
-
- public Stax2FilteredEventReader(XMLEventReader2 r, EventFilter f)
- {
- mReader = r;
- mFilter = f;
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLEventReader implementation
- ////////////////////////////////////////////////////
- */
-
- public void close()
- throws XMLStreamException
- {
- mReader.close();
- }
-
- public String getElementText()
- throws XMLStreamException
- {
- // Is this enough?
- return mReader.getElementText();
- }
-
- public Object getProperty(String name) {
- return mReader.getProperty(name);
- }
-
- public boolean hasNext()
- {
- try {
- return (peek() != null);
- } catch (XMLStreamException sex) { // shouldn't happen, but...
- throw new RuntimeException(sex);
- }
- }
-
- public XMLEvent nextEvent()
- throws XMLStreamException
- {
- while (true) {
- XMLEvent evt = mReader.nextEvent();
- if (evt == null || mFilter.accept(evt)) {
- // should never get null, actually, but...
- return evt;
- }
- }
- }
-
- public Object next()
- {
- try {
- return nextEvent();
- } catch (XMLStreamException sex) {
- throw new RuntimeException(sex);
- }
- }
-
- public XMLEvent nextTag()
- throws XMLStreamException
- {
- // This can be implemented very similar to next()...
-
- while (true) {
- XMLEvent evt = mReader.nextTag();
- if (evt == null || mFilter.accept(evt)) {
- return evt;
- }
- }
- }
-
- /**
- * This is bit tricky to implement, but it should filter out
- * events just as nextEvent() would.
- */
- public XMLEvent peek()
- throws XMLStreamException
- {
- while (true) {
- XMLEvent evt = mReader.peek();
- if (evt == null || mFilter.accept(evt)) {
- return evt;
- }
- // Need to discard as long as we have events:
- mReader.nextEvent();
- }
- }
-
- /**
- * Note: only here because we implement Iterator interface
- */
- public void remove() { // let's let underlying impl fail on it
- mReader.remove();
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLEventReader2 implementation
- ////////////////////////////////////////////////////
- */
-
- public boolean hasNextEvent()
- throws XMLStreamException
- {
- return (peek() != null);
- }
-
- public boolean isPropertySupported(String name)
- {
- return mReader.isPropertySupported(name);
- }
-
- public boolean setProperty(String name, Object value)
- {
- return mReader.setProperty(name, value);
- }
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/SingletonIterator.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/SingletonIterator.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/SingletonIterator.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/SingletonIterator.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,36 +0,0 @@
-package org.codehaus.stax2.ri;
-
-import java.util.Iterator;
-
-/**
- * Simple read-only iterator that iterators over one specific item, passed
- * in as constructor argument.
- */
-public class SingletonIterator
- implements Iterator
-{
- private final Object mValue;
-
- private boolean mDone = false;
-
- public SingletonIterator(Object value) {
- mValue = value;
- }
-
- public boolean hasNext() {
- return !mDone;
- }
-
- public Object next() {
- if (mDone) {
- throw new java.util.NoSuchElementException();
- }
- mDone = true;
- return mValue;
- }
-
- public void remove()
- {
- throw new UnsupportedOperationException("Can not remove item from SingletonIterator.");
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2EventFactoryImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2EventFactoryImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2EventFactoryImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2EventFactoryImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,203 +0,0 @@
-package org.codehaus.stax2.ri;
-
-import java.util.Iterator;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-import javax.xml.stream.events.*;
-
-import org.codehaus.stax2.evt.XMLEventFactory2;
-import org.codehaus.stax2.evt.DTD2;
-
-import org.codehaus.stax2.ri.evt.*;
-
-/**
- * This is an abstract almost complete plain vanilla implementation of
- * {@link XMLEventFactory2}.
- * It can be used as a building block for concrete implementations:
- * the minimal requirement is to implement createQName
- * methods.
- *
- * @author Tatu Saloranta
- *
- * @since 3.0
- */
-public abstract class Stax2EventFactoryImpl
- extends XMLEventFactory2
-{
- protected Location mLocation;
-
- public Stax2EventFactoryImpl() { }
-
- /*
- /////////////////////////////////////////////////////////////
- // XMLEventFactory API
- /////////////////////////////////////////////////////////////
- */
-
- public Attribute createAttribute(QName name, String value) {
- return new AttributeEventImpl(mLocation, name, value, true);
- }
-
- public Attribute createAttribute(String localName, String value) {
- return new AttributeEventImpl(mLocation, localName, null, null, value, true);
- }
-
- public Attribute createAttribute(String prefix, String nsURI,
- String localName, String value)
- {
- return new AttributeEventImpl(mLocation, localName, nsURI, prefix, value, true);
- }
-
- public Characters createCData(String content) {
- return new CharactersEventImpl(mLocation, content, true);
- }
-
- public Characters createCharacters(String content) {
- return new CharactersEventImpl(mLocation, content, false);
- }
-
- public Comment createComment(String text) {
- return new CommentEventImpl(mLocation, text);
- }
-
- /**
- * Note: constructing DTD events this way means that there will be no
- * internal presentation of actual DTD; no parsing is implied by
- * construction.
- */
- public DTD createDTD(String dtd) {
- return new DTDEventImpl(mLocation, dtd);
- }
-
- public EndDocument createEndDocument() {
- return new EndDocumentEventImpl(mLocation);
- }
-
- public EndElement createEndElement(QName name, Iterator namespaces) {
- return new EndElementEventImpl(mLocation, name, namespaces);
- }
-
- public EndElement createEndElement(String prefix, String nsURI,
- String localName)
- {
- return createEndElement(createQName(nsURI, localName), null);
- }
-
- public EndElement createEndElement(String prefix, String nsURI,
- String localName, Iterator ns)
- {
- return createEndElement(createQName(nsURI, localName, prefix), ns);
- }
-
- public EntityReference createEntityReference(String name, EntityDeclaration decl)
- {
- return new EntityReferenceEventImpl(mLocation, decl);
- }
-
- public Characters createIgnorableSpace(String content) {
- return CharactersEventImpl.createIgnorableWS(mLocation, content);
- }
-
- public Namespace createNamespace(String nsURI) {
- return NamespaceEventImpl.constructDefaultNamespace(mLocation, nsURI);
- }
-
- public Namespace createNamespace(String prefix, String nsURI) {
- return NamespaceEventImpl.constructNamespace(mLocation, prefix, nsURI);
- }
-
- public ProcessingInstruction createProcessingInstruction(String target, String data) {
- return new ProcInstrEventImpl(mLocation, target, data);
- }
-
- public Characters createSpace(String content) {
- return CharactersEventImpl.createNonIgnorableWS(mLocation, content);
- }
-
- public StartDocument createStartDocument() {
- return new StartDocumentEventImpl(mLocation);
- }
-
- public StartDocument createStartDocument(String encoding) {
- return new StartDocumentEventImpl(mLocation, encoding);
- }
-
- public StartDocument createStartDocument(String encoding, String version) {
- return new StartDocumentEventImpl(mLocation, encoding, version);
- }
-
- public StartDocument createStartDocument(String encoding, String version, boolean standalone)
- {
- return new StartDocumentEventImpl(mLocation, encoding, version,
- true, standalone);
- }
-
- public StartElement createStartElement(QName name, Iterator attr, Iterator ns)
- {
- return createStartElement(name, attr, ns, null);
- }
-
- public StartElement createStartElement(String prefix, String nsURI, String localName)
- {
- return createStartElement(createQName(nsURI, localName, prefix),
- null, null, null);
- }
-
- public StartElement createStartElement(String prefix, String nsURI,
- String localName, Iterator attr,
- Iterator ns)
- {
- return createStartElement(createQName(nsURI, localName, prefix), attr, ns,
- null);
- }
-
- public StartElement createStartElement(String prefix, String nsURI,
- String localName, Iterator attr,
- Iterator ns, NamespaceContext nsCtxt)
- {
- return createStartElement(createQName(nsURI, localName, prefix),
- attr, ns, nsCtxt);
- }
-
- public void setLocation(Location loc)
- {
- mLocation = loc;
- }
-
- /*
- /////////////////////////////////////////////////////////////
- // XMLEventFactory2 methods
- /////////////////////////////////////////////////////////////
- */
-
- public DTD2 createDTD(String rootName, String sysId, String pubId,
- String intSubset)
- {
- return new DTDEventImpl(mLocation, rootName, sysId, pubId, intSubset, null);
- }
-
- public DTD2 createDTD(String rootName, String sysId, String pubId,
- String intSubset, Object processedDTD)
- {
- return new DTDEventImpl(mLocation, rootName, sysId, pubId, intSubset,
- processedDTD);
- }
-
- /*
- /////////////////////////////////////////////////////////////
- // Helper methods, overridable
- /////////////////////////////////////////////////////////////
- */
-
- protected abstract QName createQName(String nsURI, String localName);
-
- protected abstract QName createQName(String nsURI, String localName, String prefix);
-
- protected StartElement createStartElement(QName name, Iterator attr,
- Iterator ns, NamespaceContext ctxt)
- {
- return StartElementEventImpl.construct(mLocation, name, attr, ns, ctxt);
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2EventReaderImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2EventReaderImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2EventReaderImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2EventReaderImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,530 +0,0 @@
-/* Woodstox XML processor
- *
- * Copyright (c) 2004- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in the file LICENSE which is
- * included with the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri;
-
-import java.util.NoSuchElementException;
-
-import javax.xml.stream.*;
-import javax.xml.stream.events.*;
-import javax.xml.stream.util.XMLEventAllocator;
-
-import org.codehaus.stax2.XMLEventReader2;
-import org.codehaus.stax2.XMLStreamReader2;
-
-/**
- * Almost complete implementation of {@link XMLEventReader2}, built on top of
- * a generic {@link XMLStreamReader} implementation (using aggregation).
- * Designed to be used by concrete Stax2 implementations to provide
- * full Event API implementation with minimal effort.
- *
- *
- */
-public abstract class Stax2EventReaderImpl
- implements XMLEventReader2,
- XMLStreamConstants
-{
- // // // Enumerated state ids
-
- protected final static int STATE_INITIAL = 1;
- protected final static int STATE_END_OF_INPUT = 2;
- protected final static int STATE_CONTENT = 3;
-
-
- // // // Enumerated error case ids
-
- /**
- * Current state when getElementText() called not START_ELEMENT
- */
- protected final static int ERR_GETELEMTEXT_NOT_START_ELEM = 1;
-
- /**
- * Encountered non-textual event (other than closing END_ELEMENT)
- * when collecting text for getElementText()
- */
- protected final static int ERR_GETELEMTEXT_NON_TEXT_EVENT = 2;
-
- /**
- * Encountered CHARACTERS or CDATA that contains non-white space
- * char(s), when trying to locate tag with nextTag()
- */
- protected final static int ERR_NEXTTAG_NON_WS_TEXT = 3;
-
- /**
- * Encountered non-skippable non-text/element event with
- * nextTag()
- */
- protected final static int ERR_NEXTTAG_WRONG_TYPE = 4;
-
- /*
- ///////////////////////////////////////////
- // Configuration
- ///////////////////////////////////////////
- */
-
- protected final XMLEventAllocator mAllocator;
-
- protected final XMLStreamReader2 mReader;
-
- /*
- ///////////////////////////////////////////
- // State
- ///////////////////////////////////////////
- */
-
- /**
- * Event that has been peeked, ie. loaded without call to
- * {@link #nextEvent}; will be returned and cleared by
- * call to {@link #nextEvent} (or, returned again if peeked
- * again)
- */
- private XMLEvent mPeekedEvent = null;
-
- /**
- * High-level state indicator, with currently three values:
- * whether we are initializing (need to synthetize START_DOCUMENT),
- * at END_OF_INPUT (end-of-doc), or otherwise, normal operation.
- * Useful in simplifying some methods, as well as to make sure
- * that independent of how stream reader handles things, event reader
- * can reliably detect End-Of-Document.
- */
- protected int mState = STATE_INITIAL;
-
- /**
- * This variable keeps track of the type of the 'previous' event
- * when peeking for the next Event. It is needed for some functionality,
- * to remember state even when underlying parser has to move to peek
- * the next event.
- */
- protected int mPrePeekEvent = START_DOCUMENT;
-
- /*
- ///////////////////////////////////////////
- // Construction
- ///////////////////////////////////////////
- */
-
- protected Stax2EventReaderImpl(XMLEventAllocator a, XMLStreamReader2 r)
- {
- mAllocator = a;
- mReader = r;
- }
-
- /*
- //////////////////////////////////////////////////////
- // Abstract methods sub-classes have to implement
- //////////////////////////////////////////////////////
- */
-
- public abstract boolean isPropertySupported(String name);
-
- public abstract boolean setProperty(String name, Object value);
-
- /**
- * Method called upon encountering a problem that should result
- * in an exception being thrown. If non-null String is returned.
- * that will be used as the message of exception thrown; if null,
- * a standard message will be used instead.
- *
- * @param errorType Type of the problem, one of ERR_
- * constants
- * @param eventType Type of the event that triggered the problem,
- * if any; -1 if not available.
- */
- protected abstract String getErrorDesc(int errorType, int eventType);
-
- /*
- //////////////////////////////////////////////////////
- // XMLEventReader API
- //////////////////////////////////////////////////////
- */
-
- public void close()
- throws XMLStreamException
- {
- mReader.close();
- }
-
- public String getElementText()
- throws XMLStreamException
- {
- /* Simple, if no peeking occured: can just forward this to the
- * underlying parser
- */
- if (mPeekedEvent == null) {
- return mReader.getElementText();
- }
-
- XMLEvent evt = mPeekedEvent;
- mPeekedEvent = null;
-
- /* Otherwise need to verify that we are currently over START_ELEMENT.
- * Problem is we have already went past it...
- */
- if (mPrePeekEvent != START_ELEMENT) {
- reportProblem(findErrorDesc(ERR_GETELEMTEXT_NOT_START_ELEM, mPrePeekEvent));
- }
- // ??? do we need to update mPrePeekEvent now
-
- String str = null;
- StringBuffer sb = null;
-
- /* Ok, fine, then just need to loop through and get all the
- * text...
- */
- for (; true; evt = nextEvent()) {
- if (evt.isEndElement()) {
- break;
- }
- int type = evt.getEventType();
- if (type == COMMENT || type == PROCESSING_INSTRUCTION) {
- // can/should just ignore them
- continue;
- }
- if (!evt.isCharacters()) {
- reportProblem(findErrorDesc(ERR_GETELEMTEXT_NON_TEXT_EVENT, type));
- }
- String curr = evt.asCharacters().getData();
- if (str == null) {
- str = curr;
- } else {
- if (sb == null) {
- sb = new StringBuffer(str.length() + curr.length());
- sb.append(str);
- }
- sb.append(curr);
- }
- }
-
- if (sb != null) {
- return sb.toString();
- }
- return (str == null) ? "" : str;
- }
-
- public Object getProperty(String name) {
- return mReader.getProperty(name);
- }
-
- public boolean hasNext() {
- return (mState != STATE_END_OF_INPUT);
- }
-
- public XMLEvent nextEvent()
- throws XMLStreamException
- {
- if (mState == STATE_END_OF_INPUT) {
- throwEndOfInput();
- } else if (mState == STATE_INITIAL) {
- mState = STATE_CONTENT;
- return createStartDocumentEvent();
- }
- if (mPeekedEvent != null) {
- XMLEvent evt = mPeekedEvent;
- mPeekedEvent = null;
- if (evt.isEndDocument()) {
- mState = STATE_END_OF_INPUT;
- }
- return evt;
- }
- return createNextEvent(true, mReader.next());
- }
-
- public Object next() {
- try {
- return nextEvent();
- } catch (XMLStreamException sex) {
- throwUnchecked(sex);
- return null;
- }
- }
-
- public XMLEvent nextTag()
- throws XMLStreamException
- {
- // If we have peeked something, need to process it
- if (mPeekedEvent != null) {
- XMLEvent evt = mPeekedEvent;
- mPeekedEvent = null;
- int type = evt.getEventType();
- switch (type) {
- case END_DOCUMENT:
- return null;
- case START_DOCUMENT:
- // Need to skip START_DOCUMENT to get the root elem
- break;
- case SPACE:
- // Ignorable WS is just fine
- break;
-
- /* !!! 07-Dec-2004, TSa: Specs are mum about Comments and PIs.
- * But why would they not be skipped just like what
- * the stream reader does?
- */
- case COMMENT:
- case PROCESSING_INSTRUCTION:
- break;
- case CDATA:
- case CHARACTERS:
- if (((Characters) evt).isWhiteSpace()) {
- break;
- }
- reportProblem(findErrorDesc(ERR_NEXTTAG_NON_WS_TEXT, type));
- break; // never gets here, but some compilers whine without...
- case START_ELEMENT:
- case END_ELEMENT:
- return evt;
-
- default:
- reportProblem(findErrorDesc(ERR_NEXTTAG_WRONG_TYPE, type));
- }
- } else {
- /* 13-Sep-2005, TSa: As pointed out by Patrick, we may need to
- * initialize the state here, too; otherwise peek() won't work
- * correctly. The problem is that following loop's get method
- * does not use event reader's method but underlying reader's.
- * As such, it won't update state: most importantly, initial
- * state may not be changed to non-initial.
- */
- if (mState == STATE_INITIAL) {
- mState = STATE_CONTENT;
- }
- }
-
- while (true) {
- int next = mReader.next();
-
- switch (next) {
- case END_DOCUMENT:
- return null;
- case SPACE:
- /* !!! 07-Dec-2004, TSa: Specs are mum about Comments and PIs.
- * But why would they not be skipped just like what
- * the stream reader does?
- */
- case COMMENT:
- case PROCESSING_INSTRUCTION:
- continue;
- case CDATA:
- case CHARACTERS:
- if (mReader.isWhiteSpace()) {
- continue;
- }
- reportProblem(findErrorDesc(ERR_NEXTTAG_NON_WS_TEXT, next));
- break; // just to keep Jikes happy...
-
- case START_ELEMENT:
- case END_ELEMENT:
- return createNextEvent(false, next);
-
- default:
- reportProblem(findErrorDesc(ERR_NEXTTAG_WRONG_TYPE, next));
- }
- }
- }
-
- public XMLEvent peek()
- throws XMLStreamException
- {
- if (mPeekedEvent == null) {
- if (mState == STATE_END_OF_INPUT) {
- // 06-Mar-2006, TSa: Fixed as per Arjen's suggestion:
- //throwEndOfInput();
- return null;
- }
- if (mState == STATE_INITIAL) {
- // Not sure what it should be... but this should do:
- mPrePeekEvent = START_DOCUMENT;
- mPeekedEvent = createStartDocumentEvent();
- mState = STATE_CONTENT;
- } else {
- mPrePeekEvent = mReader.getEventType();
- mPeekedEvent = createNextEvent(false, mReader.next());
- }
- }
- return mPeekedEvent;
- }
-
- /**
- * Note: only here because we implement Iterator interface. Will not
- * work, don't bother calling it.
- */
- public void remove() {
- throw new UnsupportedOperationException("Can not remove events from XMLEventReader.");
- }
-
- /*
- //////////////////////////////////////////////////////
- // XMLEventReader2 API
- //////////////////////////////////////////////////////
- */
-
- /**
- *getErrorDesc()
first, and only
- * if no message found, uses default messages defined here.
- */
- private final String findErrorDesc(int errorType, int currEvent)
- {
- String msg = getErrorDesc(errorType, currEvent);
- if (msg != null) {
- return msg;
- }
- switch (errorType) {
- case ERR_GETELEMTEXT_NOT_START_ELEM:
- return "Current state not START_ELEMENT when calling getElementText()";
- case ERR_GETELEMTEXT_NON_TEXT_EVENT:
- return "Expected a text token";
- case ERR_NEXTTAG_NON_WS_TEXT:
- return "Only all-whitespace CHARACTERS/CDATA (or SPACE) allowed for nextTag()";
- case ERR_NEXTTAG_WRONG_TYPE:
- return "Should only encounter START_ELEMENT/END_ELEMENT, SPACE, or all-white-space CHARACTERS";
- }
-
- // should never happen, but it'd be bad to throw another exception...
- return "Internal error (unrecognized error type: "+errorType+")";
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2EventWriterImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2EventWriterImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2EventWriterImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2EventWriterImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,214 +0,0 @@
-package org.codehaus.stax2.ri;
-
-import java.util.Iterator;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-import javax.xml.stream.events.*;
-
-import org.codehaus.stax2.*;
-import org.codehaus.stax2.evt.XMLEvent2;
-
-/**
- * Simple implementation of {@link XMLEventWriter}.
- */
-public class Stax2EventWriterImpl
- implements XMLEventWriter,
- XMLStreamConstants
-{
- final XMLStreamWriter2 mWriter;
-
- /*
- ////////////////////////////////////////////////////
- // Construction, init
- ////////////////////////////////////////////////////
- */
-
- public Stax2EventWriterImpl(XMLStreamWriter2 sw)
- {
- mWriter = sw;
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLEventWriter API
- ////////////////////////////////////////////////////
- */
-
- /**
- * Basic implementation of the method which will use event implementations
- * available as part of the reference implementation.
- *
- *
- *
- * @author Tatu Saloranta
- */
-public class Stax2ReaderAdapter
- extends StreamReaderDelegate /* from Stax 1.0 */
- implements XMLStreamReader2 /* From Stax2 */
- ,AttributeInfo
- ,DTDInfo
- ,LocationInfo
-{
- final static int INT_SPACE = 0x0020;
-
- final private static int MASK_GET_ELEMENT_TEXT =
- (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE)
- | (1 << ENTITY_REFERENCE);
-
- final protected static int MASK_TYPED_ACCESS_BINARY =
- (1 << START_ELEMENT) // note: END_ELEMENT handled separately
- | (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE)
- ;
-
- /**
- * Factory used for constructing decoders we need for typed access
- */
- protected ValueDecoderFactory _decoderFactory;
-
- /**
- * Lazily-constructed decoder object for decoding base64 encoded
- * binary content.
- */
- protected StringBase64Decoder _base64Decoder = null;
-
- /**
- * Number of open (start) elements currently.
- */
- protected int _depth = 0;
-
- /**
- * Content temporarily cached to be used for decoding typed content
- * that is in chunked mode (int/long/float/double arrays, base64
- * encoded binary data)
- */
- protected String _typedContent;
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // Life-cycle methods
- ///////////////////////////////////////////////////////////////////////
- */
-
- protected Stax2ReaderAdapter(XMLStreamReader sr)
- {
- super(sr);
- }
-
- /**
- * Method that should be used to add dynamic support for
- * {@link XMLStreamReader2}. Method will check whether the
- * stream reader passed happens to be a {@link XMLStreamReader2};
- * and if it is, return it properly cast. If not, it will create
- * necessary wrapper.
- */
- public static XMLStreamReader2 wrapIfNecessary(XMLStreamReader sr)
- {
- if (sr instanceof XMLStreamReader2) {
- return (XMLStreamReader2) sr;
- }
- return new Stax2ReaderAdapter(sr);
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // Stax 1.0 methods overridden
- ///////////////////////////////////////////////////////////////////////
- */
-
- public int next()
- throws XMLStreamException
- {
- /* First special check: are we in the middle of chunked
- * decode operation? If so, we'll just end it...
- */
- if (_typedContent != null) {
- _typedContent = null;
- return XMLStreamConstants.END_ELEMENT;
- }
-
- int type = super.next();
- if (type == XMLStreamConstants.START_ELEMENT) {
- ++_depth;
- } else if (type == XMLStreamConstants.END_ELEMENT) {
- --_depth;
- }
- return type;
- }
-
- /**
- * As per [WSTX-254], must override and add handling for depth calculation here.
- */
- public String getElementText() throws XMLStreamException
- {
- /* Should not succeed (as per specs) if not pointing to START_ELEMENT, but just in
- * case some impls are more lenient, let's verify...
- */
- boolean hadStart = (getEventType() == XMLStreamConstants.START_ELEMENT);
- String text = super.getElementText();
- if (hadStart) {
- --_depth;
- }
- return text;
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // TypedXMLStreamReader, element access
- ///////////////////////////////////////////////////////////////////////
- */
-
- public boolean getElementAsBoolean() throws XMLStreamException
- {
- ValueDecoderFactory.BooleanDecoder dec = _decoderFactory().getBooleanDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public int getElementAsInt() throws XMLStreamException
- {
- ValueDecoderFactory.IntDecoder dec = _decoderFactory().getIntDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public long getElementAsLong() throws XMLStreamException
- {
- ValueDecoderFactory.LongDecoder dec = _decoderFactory().getLongDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public float getElementAsFloat() throws XMLStreamException
- {
- ValueDecoderFactory.FloatDecoder dec = _decoderFactory().getFloatDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public double getElementAsDouble() throws XMLStreamException
- {
- ValueDecoderFactory.DoubleDecoder dec = _decoderFactory().getDoubleDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public BigInteger getElementAsInteger() throws XMLStreamException
- {
- ValueDecoderFactory.IntegerDecoder dec = _decoderFactory().getIntegerDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public BigDecimal getElementAsDecimal() throws XMLStreamException
- {
- ValueDecoderFactory.DecimalDecoder dec = _decoderFactory().getDecimalDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public QName getElementAsQName() throws XMLStreamException
- {
- ValueDecoderFactory.QNameDecoder dec = _decoderFactory().getQNameDecoder(getNamespaceContext());
- getElementAs(dec);
- return dec.getValue();
- }
-
- public byte[] getElementAsBinary() throws XMLStreamException
- {
- return getElementAsBinary(Base64Variants.getDefaultVariant());
- }
-
- public byte[] getElementAsBinary(Base64Variant v) throws XMLStreamException
- {
- // note: code here is similar to Base64DecoderBase.aggregateAll(), see comments there
- Stax2Util.ByteAggregator aggr = _base64Decoder().getByteAggregator();
- byte[] buffer = aggr.startAggregation();
- while (true) {
- int offset = 0;
- int len = buffer.length;
- do {
- int readCount = readElementAsBinary(buffer, offset, len, v);
- if (readCount < 1) { // all done!
- return aggr.aggregateAll(buffer, offset);
- }
- offset += readCount;
- len -= readCount;
- } while (len > 0);
- buffer = aggr.addFullBlock(buffer);
- }
- }
-
- public void getElementAs(TypedValueDecoder tvd) throws XMLStreamException
- {
- String value = getElementText();
- value = Stax2Util.trimSpaces(value);
- try {
- if (value == null) {
- tvd.handleEmptyValue();
- } else {
- tvd.decode(value);
- }
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, value);
- }
- }
-
- public int readElementAsIntArray(int[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getIntArrayDecoder(value, from, length));
- }
-
- public int readElementAsLongArray(long[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getLongArrayDecoder(value, from, length));
- }
-
- public int readElementAsFloatArray(float[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getFloatArrayDecoder(value, from, length));
- }
-
- public int readElementAsDoubleArray(double[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getDoubleArrayDecoder(value, from, length));
- }
-
- public int readElementAsArray(TypedArrayDecoder tad) throws XMLStreamException
- {
- // Are we started?
- if (_typedContent == null) { // nope, not yet (or not any more?)
- int type = getEventType();
- if (type == END_ELEMENT) { // already done
- return -1;
- }
- if (type != START_ELEMENT) {
- throw new IllegalStateException("First call to readElementAsArray() must be for a START_ELEMENT");
- }
- _typedContent = getElementText();
- /* This will move current event to END_ELEMENT, too...
- * But should we mask it (and claim it's, say, CHARACTERS)
- * or expose as is? For now, let's do latter, simplest
- */
- }
- // Ok, so what do we have left?
- String input = _typedContent;
- final int end = input.length();
- int ptr = 0;
- int count = 0;
- String value = null;
-
- try {
- decode_loop:
- while (ptr < end) {
- // First, any space to skip?
- while (input.charAt(ptr) <= INT_SPACE) {
- if (++ptr >= end) {
- break decode_loop;
- }
- }
- // Then let's figure out non-space char (token)
- int start = ptr;
- ++ptr;
- while (ptr < end && input.charAt(ptr) > INT_SPACE) {
- ++ptr;
- }
- ++count;
- // And there we have it
- value = input.substring(start, ptr);
- // Plus, can skip trailing space (or at end, just beyond it)
- ++ptr;
- if (tad.decodeValue(value)) {
- break;
- }
- }
- } catch (IllegalArgumentException iae) {
- // Need to convert to a checked stream exception
- /* Hmmh. This is not an accurate location... but it's
- * about the best we can do
- */
- Location loc = getLocation();
- throw new TypedXMLStreamException(value, iae.getMessage(), loc, iae);
- } finally {
- int len = end-ptr;
- // null works well as the marker for complete processing
- _typedContent = (len < 1) ? null : input.substring(ptr);
- }
- return (count < 1) ? -1 : count;
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // TypedXMLStreamReader2 implementation, binary data
- ///////////////////////////////////////////////////////////////////////
- */
-
- public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength)
- throws XMLStreamException
- {
- return readElementAsBinary(resultBuffer, offset, maxLength, Base64Variants.getDefaultVariant());
- }
-
-
- public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength, Base64Variant v)
- throws XMLStreamException
- {
- if (resultBuffer == null) {
- throw new IllegalArgumentException("resultBuffer is null");
- }
- if (offset < 0) {
- throw new IllegalArgumentException("Illegal offset ("+offset+"), must be [0, "+resultBuffer.length+"[");
- }
- if (maxLength < 1 || (offset + maxLength) > resultBuffer.length) {
- if (maxLength == 0) { // special case, allowed, but won't do anything
- return 0;
- }
- throw new IllegalArgumentException("Illegal maxLength ("+maxLength+"), has to be positive number, and offset+maxLength can not exceed"+resultBuffer.length);
- }
-
- final StringBase64Decoder dec = _base64Decoder();
- int type = getEventType();
- // First things first: must be acceptable start state:
- if (((1 << type) & MASK_TYPED_ACCESS_BINARY) == 0) {
- if (type == END_ELEMENT) {
- // Minor complication: may have unflushed stuff (non-padded versions)
- if (!dec.hasData()) {
- return -1;
- }
- } else {
- throwNotStartElemOrTextual(type);
- }
- }
-
- // Are we just starting (START_ELEMENT)?
- if (type == START_ELEMENT) {
- // Just need to locate the first text segment (or reach END_ELEMENT)
- while (true) {
- type = next();
- if (type == END_ELEMENT) {
- // Simple... no textual content
- return -1;
- }
- if (type == COMMENT || type == PROCESSING_INSTRUCTION) {
- continue;
- }
- if (((1 << type) & MASK_GET_ELEMENT_TEXT) == 0) {
- throwNotStartElemOrTextual(type);
- }
- dec.init(v, true, getText());
- break;
- }
- }
-
- int totalCount = 0;
-
- main_loop:
- while (true) {
- // Ok, decode:
- int count;
- try {
- count = dec.decode(resultBuffer, offset, maxLength);
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, "");
- }
- offset += count;
- totalCount += count;
- maxLength -= count;
-
- /* And if we filled the buffer we are done. Or, an edge
- * case: reached END_ELEMENT (for non-padded variant)
- */
- if (maxLength < 1 || getEventType() == END_ELEMENT) {
- break;
- }
- // Otherwise need to advance to the next event
- while (true) {
- type = next();
- if (type == COMMENT || type == PROCESSING_INSTRUCTION
- || type == SPACE) { // space is ignorable too
- continue;
- }
- if (type == END_ELEMENT) {
- /* Just need to verify we don't have partial stuff
- * (missing one to three characters of a full quartet
- * that encodes 1 - 3 bytes). Also: non-padding
- * variants can be in incomplete state, from which
- * data may need to be flushed...
- */
- int left = dec.endOfContent();
- if (left < 0) { // incomplete, error
- throw _constructTypeException("Incomplete base64 triplet at the end of decoded content", "");
- } else if (left > 0) { // 1 or 2 more bytes of data, loop some more
- continue main_loop;
- }
- // Otherwise, no more data, we are done
- break main_loop;
- }
- if (((1 << type) & MASK_GET_ELEMENT_TEXT) == 0) {
- throwNotStartElemOrTextual(type);
- }
- dec.init(v, false, getText());
- break;
- }
- }
-
- // If nothing was found, needs to be indicated via -1, not 0
- return (totalCount > 0) ? totalCount : -1;
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // TypedXMLStreamReader, attribute access
- ///////////////////////////////////////////////////////////////////////
- */
-
- public int getAttributeIndex(String namespaceURI, String localName)
- {
- return findAttributeIndex(namespaceURI, localName);
- }
-
- public boolean getAttributeAsBoolean(int index) throws XMLStreamException
- {
- ValueDecoderFactory.BooleanDecoder dec = _decoderFactory().getBooleanDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public int getAttributeAsInt(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntDecoder dec = _decoderFactory().getIntDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public long getAttributeAsLong(int index) throws XMLStreamException
- {
- ValueDecoderFactory.LongDecoder dec = _decoderFactory().getLongDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public float getAttributeAsFloat(int index) throws XMLStreamException
- {
- ValueDecoderFactory.FloatDecoder dec = _decoderFactory().getFloatDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public double getAttributeAsDouble(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DoubleDecoder dec = _decoderFactory().getDoubleDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public BigInteger getAttributeAsInteger(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntegerDecoder dec = _decoderFactory().getIntegerDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public BigDecimal getAttributeAsDecimal(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DecimalDecoder dec = _decoderFactory().getDecimalDecoder();
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public QName getAttributeAsQName(int index) throws XMLStreamException
- {
- ValueDecoderFactory.QNameDecoder dec = _decoderFactory().getQNameDecoder(getNamespaceContext());
- getAttributeAs(index, dec);
- return dec.getValue();
- }
-
- public void getAttributeAs(int index, TypedValueDecoder tvd) throws XMLStreamException
- {
- String value = getAttributeValue(index);
- value = Stax2Util.trimSpaces(value);
- try {
- if (value == null) {
- tvd.handleEmptyValue();
- } else {
- tvd.decode(value);
- }
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, value);
- }
- }
-
- public int[] getAttributeAsIntArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.IntArrayDecoder dec = _decoderFactory().getIntArrayDecoder();
- _getAttributeAsArray(dec, getAttributeValue(index));
- return dec.getValues();
- }
-
- public long[] getAttributeAsLongArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.LongArrayDecoder dec = _decoderFactory().getLongArrayDecoder();
- _getAttributeAsArray(dec, getAttributeValue(index));
- return dec.getValues();
- }
-
- public float[] getAttributeAsFloatArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.FloatArrayDecoder dec = _decoderFactory().getFloatArrayDecoder();
- _getAttributeAsArray(dec, getAttributeValue(index));
- return dec.getValues();
- }
-
- public double[] getAttributeAsDoubleArray(int index) throws XMLStreamException
- {
- ValueDecoderFactory.DoubleArrayDecoder dec = _decoderFactory().getDoubleArrayDecoder();
- _getAttributeAsArray(dec, getAttributeValue(index));
- return dec.getValues();
- }
-
- public int getAttributeAsArray(int index, TypedArrayDecoder tad) throws XMLStreamException
- {
- return _getAttributeAsArray(tad, getAttributeValue(index));
- }
-
- protected int _getAttributeAsArray(TypedArrayDecoder tad, String attrValue) throws XMLStreamException
- {
- int ptr = 0;
- int start = 0;
- final int end = attrValue.length();
- String lexical = null;
- int count = 0;
-
- try {
- decode_loop:
- while (ptr < end) {
- // First, any space to skip?
- while (attrValue.charAt(ptr) <= INT_SPACE) {
- if (++ptr >= end) {
- break decode_loop;
- }
- }
- // Then let's figure out non-space char (token)
- start = ptr;
- ++ptr;
- while (ptr < end && attrValue.charAt(ptr) > INT_SPACE) {
- ++ptr;
- }
- int tokenEnd = ptr;
- ++ptr; // to skip trailing space (or, beyond end)
- // And there we have it
- lexical = attrValue.substring(start, tokenEnd);
- ++count;
- if (tad.decodeValue(lexical)) {
- if (!checkExpand(tad)) {
- break;
- }
- }
- }
- } catch (IllegalArgumentException iae) {
- // Need to convert to a checked stream exception
- Location loc = getLocation();
- throw new TypedXMLStreamException(lexical, iae.getMessage(), loc, iae);
- }
- return count;
- }
-
- /**
- * Internal method used to see if we can expand the buffer that
- * the array decoder has. Bit messy, but simpler than having
- * separately typed instances; and called rarely so that performance
- * downside of instanceof is irrelevant.
- */
- private final boolean checkExpand(TypedArrayDecoder tad)
- {
- if (tad instanceof ValueDecoderFactory.BaseArrayDecoder) {
- ((ValueDecoderFactory.BaseArrayDecoder) tad).expand();
- return true;
- }
- return false;
- }
-
- public byte[] getAttributeAsBinary(int index) throws XMLStreamException
- {
- return getAttributeAsBinary(index, Base64Variants.getDefaultVariant());
- }
-
- public byte[] getAttributeAsBinary(int index, Base64Variant v) throws XMLStreamException
- {
- String lexical = getAttributeValue(index);
- final StringBase64Decoder dec = _base64Decoder();
- dec.init(v, true, lexical);
- try {
- return dec.decodeCompletely();
- } catch (IllegalArgumentException iae) {
- throw new TypedXMLStreamException(lexical, iae.getMessage(), getLocation(), iae);
- }
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // XMLStreamReader2 (StAX2) implementation
- ///////////////////////////////////////////////////////////////////////
- */
-
- // // // StAX2, per-reader configuration
-
- public Object getFeature(String name)
- {
- // No features defined
- return null;
- }
-
- public void setFeature(String name, Object value)
- {
- // No features defined
- }
-
- // NOTE: getProperty() defined in Stax 1.0 interface
-
- public boolean isPropertySupported(String name) {
- /* No way to cleanly implement this using just Stax 1.0
- * interface, so let's be conservative and decline any knowledge
- * of properties...
- */
- return false;
- }
-
- public boolean setProperty(String name, Object value)
- {
- return false; // could throw an exception too
- }
-
- // // // StAX2, additional traversal methods
-
- public void skipElement() throws XMLStreamException
- {
- if (getEventType() != START_ELEMENT) {
- throwNotStartElem(getEventType());
- }
- int nesting = 1; // need one more end elements than start elements
-
- while (true) {
- int type = next();
- if (type == START_ELEMENT) {
- ++nesting;
- } else if (type == END_ELEMENT) {
- if (--nesting == 0) {
- break;
- }
- }
- }
- }
-
- // // // StAX2, additional attribute access
-
- public AttributeInfo getAttributeInfo() throws XMLStreamException
- {
- if (getEventType() != START_ELEMENT) {
- throwNotStartElem(getEventType());
- }
- return this;
- }
-
- // // // StAX2, Additional DTD access
-
- public DTDInfo getDTDInfo() throws XMLStreamException
- {
- if (getEventType() != DTD) {
- return null;
- }
- return this;
- }
-
- // // // StAX2, Additional location information
-
- /**
- * Location information is always accessible, for this reader.
- */
- public final LocationInfo getLocationInfo() {
- return this;
- }
-
- // // // StAX2, Pass-through text accessors
-
- public int getText(Writer w, boolean preserveContents)
- throws IOException, XMLStreamException
- {
- char[] cbuf = getTextCharacters();
- int start = getTextStart();
- int len = getTextLength();
-
- if (len > 0) {
- w.write(cbuf, start, len);
- }
- return len;
- }
-
- // // // StAX 2, Other accessors
-
- /**
- * @return Number of open elements in the stack; 0 when parser is in
- * prolog/epilog, 1 inside root element and so on.
- */
- public int getDepth()
- {
- /* 16-Jun-2008, tatus: Need to compensate for the fact
- * that END_ELEMENT decrements "too early"
- */
- if (getEventType() == END_ELEMENT) {
- return _depth+1;
- }
- return _depth;
- }
-
- /**
- * Alas, there is no way to find this out via Stax 1.0, so this
- * implementation always returns false.
- */
- public boolean isEmptyElement() throws XMLStreamException
- {
- return false;
- }
-
- public NamespaceContext getNonTransientNamespaceContext()
- {
- /* Too hard to construct without other info: let's bail
- * and return null; this is better than return a transient
- * one.
- */
- return null;
- }
-
- public String getPrefixedName()
- {
- switch (getEventType()) {
- case START_ELEMENT:
- case END_ELEMENT:
- {
- String prefix = getPrefix();
- String ln = getLocalName();
-
- if (prefix == null || prefix.length() == 0) {
- return ln;
- }
- StringBuffer sb = new StringBuffer(ln.length() + 1 + prefix.length());
- sb.append(prefix);
- sb.append(':');
- sb.append(ln);
- return sb.toString();
- }
- case ENTITY_REFERENCE:
- return getLocalName();
- case PROCESSING_INSTRUCTION:
- return getPITarget();
- case DTD:
- return getDTDRootName();
-
- }
- throw new IllegalStateException("Current state not START_ELEMENT, END_ELEMENT, ENTITY_REFERENCE, PROCESSING_INSTRUCTION or DTD");
- }
-
- public void closeCompletely() throws XMLStreamException
- {
- /* As usual, Stax 1.0 offers no generic way of doing just this.
- * But let's at least call the lame basic close()
- */
- close();
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // AttributeInfo implementation (StAX 2)
- ///////////////////////////////////////////////////////////////////////
- */
-
- // Already part of XMLStreamReader
- //public int getAttributeCount();
-
- public int findAttributeIndex(String nsURI, String localName)
- {
- if ("".equals(nsURI)) {
- nsURI = null;
- }
- for (int i = 0, len = getAttributeCount(); i < len; ++i) {
- if (getAttributeLocalName(i).equals(localName)) {
- String otherUri = getAttributeNamespace(i);
- if (nsURI == null) {
- if (otherUri == null || otherUri.length() == 0) {
- return i;
- }
- } else {
- if (nsURI.equals(otherUri)) {
- return i;
- }
- }
- }
- }
- return -1;
- }
-
- public int getIdAttributeIndex()
- {
- for (int i = 0, len = getAttributeCount(); i < len; ++i) {
- if ("ID".equals(getAttributeType(i))) {
- return i;
- }
- }
- return -1;
- }
-
- public int getNotationAttributeIndex()
- {
- for (int i = 0, len = getAttributeCount(); i < len; ++i) {
- if ("NOTATION".equals(getAttributeType(i))) {
- return i;
- }
- }
- return -1;
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // DTDInfo implementation (StAX 2)
- ///////////////////////////////////////////////////////////////////////
- */
-
- public Object getProcessedDTD() {
- return null;
- }
-
- public String getDTDRootName() {
- return null;
- }
-
- public String getDTDPublicId() {
- return null;
- }
-
- public String getDTDSystemId() {
- return null;
- }
-
- /**
- * @return Internal subset portion of the DOCTYPE declaration, if any;
- * empty String if none
- */
- public String getDTDInternalSubset()
- {
- /* According to basic Stax API, getText() should return
- * the internal subset. Not all implementations agree, so
- * this may or may not work.
- */
- if (getEventType() == XMLStreamConstants.DTD) {
- return getText();
- }
- return null;
- }
-
- // // StAX2, v2.0
-
- public DTDValidationSchema getProcessedDTDSchema() {
- return null;
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // LocationInfo implementation (StAX 2)
- ///////////////////////////////////////////////////////////////////////
- */
-
- // // // First, the "raw" offset accessors:
-
- public long getStartingByteOffset() {
- return -1L;
- }
-
- public long getStartingCharOffset() {
- return 0;
- }
-
- public long getEndingByteOffset() throws XMLStreamException
- {
- return -1;
- }
-
- public long getEndingCharOffset() throws XMLStreamException
- {
- return -1;
- }
-
- // // // and then the object-based access methods:
-
- public XMLStreamLocation2 getStartLocation()
- {
- /* We don't really know whether location given is current,
- * start or end, but it's the best approximation we have
- * without knowing more about impl:
- */
- return getCurrentLocation();
- }
-
- public XMLStreamLocation2 getCurrentLocation()
- {
- // Just need to adapt; no info on parent context, if any:
- return new Stax2LocationAdapter(getLocation());
- }
-
- public final XMLStreamLocation2 getEndLocation()
- throws XMLStreamException
- {
- /* We don't really know whether location given is current,
- * start or end, but it's the best approximation we have
- * without knowing more about impl:
- */
- return getCurrentLocation();
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // Stax2 validation
- ///////////////////////////////////////////////////////////////////////
- */
-
- public XMLValidator validateAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- throwUnsupported();
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- throwUnsupported();
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidator validator)
- throws XMLStreamException
- {
- throwUnsupported();
- return null;
- }
-
- public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
- {
- return null;
- }
-
- /*
- ///////////////////////////////////////////////////////////////////////
- // Internal methods
- ///////////////////////////////////////////////////////////////////////
- */
-
- protected ValueDecoderFactory _decoderFactory()
- {
- if (_decoderFactory == null) {
- _decoderFactory = new ValueDecoderFactory();
- }
- return _decoderFactory;
- }
-
- protected StringBase64Decoder _base64Decoder()
- {
- if (_base64Decoder == null) {
- _base64Decoder = new StringBase64Decoder();
- }
- return _base64Decoder;
- }
-
- protected void throwUnsupported()
- throws XMLStreamException
- {
- throw new XMLStreamException("Unsupported method");
- }
-
- protected void throwNotStartElem(int type)
- {
- throw new IllegalStateException("Current event ("+Stax2Util.eventTypeDesc(type)+") not START_ELEMENT");
- }
-
- protected void throwNotStartElemOrTextual(int type)
- {
- throw new IllegalStateException("Current event ("+Stax2Util.eventTypeDesc(type)+") not START_ELEMENT, END_ELEMENT, CHARACTERS or CDATA");
- }
-
- /**
- * Method called to wrap or convert given conversion-fail exception
- * into a full {@link TypedXMLStreamException},
- *
- * @param iae Problem as reported by converter
- * @param lexicalValue Lexical value (element content, attribute value)
- * that could not be converted succesfully.
- */
- protected TypedXMLStreamException _constructTypeException(IllegalArgumentException iae, String lexicalValue)
- {
- String msg = iae.getMessage();
- if (msg == null) {
- msg = "";
- }
- Location loc = getStartLocation();
- if (loc == null) {
- return new TypedXMLStreamException(lexicalValue, msg, iae);
- }
- return new TypedXMLStreamException(lexicalValue, msg, loc, iae);
- }
-
- protected TypedXMLStreamException _constructTypeException(String msg, String lexicalValue)
- {
- Location loc = getStartLocation();
- if (loc == null) {
- return new TypedXMLStreamException(lexicalValue, msg);
- }
- return new TypedXMLStreamException(lexicalValue, msg, loc);
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2ReaderImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2ReaderImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2ReaderImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2ReaderImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,619 +0,0 @@
-/* Stax2 API extension for Streaming Api for Xml processing (StAX).
- *
- * Copyright (c) 2006- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.codehaus.stax2.ri;
-
-import java.io.IOException;
-import java.io.Writer;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-
-import org.codehaus.stax2.*;
-import org.codehaus.stax2.typed.Base64Variant;
-import org.codehaus.stax2.typed.Base64Variants;
-import org.codehaus.stax2.typed.TypedArrayDecoder;
-import org.codehaus.stax2.typed.TypedValueDecoder;
-import org.codehaus.stax2.typed.TypedXMLStreamException;
-import org.codehaus.stax2.validation.*;
-
-import org.codehaus.stax2.ri.typed.ValueDecoderFactory;
-
-/**
- * This is a partial base implementation of {@link XMLStreamReader2},
- * the extended stream reader that is part of Stax2.
- */
-public abstract class Stax2ReaderImpl
- implements XMLStreamReader2 /* From Stax2 */
- ,AttributeInfo
- ,DTDInfo
- ,LocationInfo
-{
- /**
- * Factory used for constructing decoders we need for typed access
- */
- protected ValueDecoderFactory _decoderFactory;
-
- /*
- ////////////////////////////////////////////////////
- // Life-cycle methods
- ////////////////////////////////////////////////////
- */
-
- protected Stax2ReaderImpl()
- {
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamReader2 (StAX2) implementation
- ////////////////////////////////////////////////////
- */
-
- // // // StAX2, per-reader configuration
-
- public Object getFeature(String name)
- {
- // No features defined
- return null;
- }
-
- public void setFeature(String name, Object value)
- {
- // No features defined
- }
-
- // NOTE: getProperty() defined in Stax 1.0 interface
-
- public boolean isPropertySupported(String name) {
- /* No way to cleanly implement this using just Stax 1.0
- * interface, so let's be conservative and decline any knowledge
- * of properties...
- */
- return false;
- }
-
- public boolean setProperty(String name, Object value)
- {
- return false; // could throw an exception too
- }
-
- // // // StAX2, additional traversal methods
-
- public void skipElement() throws XMLStreamException
- {
- if (getEventType() != START_ELEMENT) {
- throwNotStartElem();
- }
- int nesting = 1; // need one more end elements than start elements
-
- while (true) {
- int type = next();
- if (type == START_ELEMENT) {
- ++nesting;
- } else if (type == END_ELEMENT) {
- if (--nesting == 0) {
- break;
- }
- }
- }
- }
-
- // // // StAX2, additional attribute access
-
- public AttributeInfo getAttributeInfo() throws XMLStreamException
- {
- if (getEventType() != START_ELEMENT) {
- throwNotStartElem();
- }
- return this;
- }
-
- // // // StAX2, Additional DTD access
-
- public DTDInfo getDTDInfo() throws XMLStreamException
- {
- if (getEventType() != DTD) {
- return null;
- }
- return this;
- }
-
- // // // StAX2, Additional location information
-
- /**
- * Location information is always accessible, for this reader.
- */
- public final LocationInfo getLocationInfo() {
- return this;
- }
-
- // // // StAX2, Pass-through text accessors
-
- public int getText(Writer w, boolean preserveContents)
- throws IOException, XMLStreamException
- {
- char[] cbuf = getTextCharacters();
- int start = getTextStart();
- int len = getTextLength();
-
- if (len > 0) {
- w.write(cbuf, start, len);
- }
- return len;
- }
-
- // // // StAX 2, Other accessors
-
- /**
- * @return Number of open elements in the stack; 0 when parser is in
- * prolog/epilog, 1 inside root element and so on.
- */
- public abstract int getDepth();
-
- public abstract boolean isEmptyElement() throws XMLStreamException;
-
- public abstract NamespaceContext getNonTransientNamespaceContext();
-
- public String getPrefixedName()
- {
- switch (getEventType()) {
- case START_ELEMENT:
- case END_ELEMENT:
- {
- String prefix = getPrefix();
- String ln = getLocalName();
-
- if (prefix == null) {
- return ln;
- }
- StringBuffer sb = new StringBuffer(ln.length() + 1 + prefix.length());
- sb.append(prefix);
- sb.append(':');
- sb.append(ln);
- return sb.toString();
- }
- case ENTITY_REFERENCE:
- return getLocalName();
- case PROCESSING_INSTRUCTION:
- return getPITarget();
- case DTD:
- return getDTDRootName();
-
- }
- throw new IllegalStateException("Current state not START_ELEMENT, END_ELEMENT, ENTITY_REFERENCE, PROCESSING_INSTRUCTION or DTD");
- }
-
- public void closeCompletely() throws XMLStreamException
- {
- /* As usual, Stax 1.0 offers no generic way of doing just this.
- * But let's at least call the lame basic close()
- */
- close();
- }
-
- /*
- ////////////////////////////////////////////////////
- // AttributeInfo implementation (StAX 2)
- ////////////////////////////////////////////////////
- */
-
- // Already part of XMLStreamReader
- //public int getAttributeCount();
-
- public int findAttributeIndex(String nsURI, String localName)
- {
- // !!! TBI
- return -1;
- }
-
- public int getIdAttributeIndex()
- {
- // !!! TBI
- return -1;
- }
-
- public int getNotationAttributeIndex()
- {
- // !!! TBI
- return -1;
- }
-
- /*
- ////////////////////////////////////////////////////
- // DTDInfo implementation (StAX 2)
- ////////////////////////////////////////////////////
- */
-
- public Object getProcessedDTD() {
- return null;
- }
-
- public String getDTDRootName() {
- return null;
- }
-
- public String getDTDPublicId() {
- return null;
- }
-
- public String getDTDSystemId() {
- return null;
- }
-
- /**
- * @return Internal subset portion of the DOCTYPE declaration, if any;
- * empty String if none
- */
- public String getDTDInternalSubset() {
- return null;
- }
-
- // // StAX2, v2.0
-
- public DTDValidationSchema getProcessedDTDSchema() {
- return null;
- }
-
- /*
- ////////////////////////////////////////////////////
- // LocationInfo implementation (StAX 2)
- ////////////////////////////////////////////////////
- */
-
- // // // First, the "raw" offset accessors:
-
- public long getStartingByteOffset() {
- return -1L;
- }
-
- public long getStartingCharOffset() {
- return 0;
- }
-
- public long getEndingByteOffset() throws XMLStreamException
- {
- return -1;
- }
-
- public long getEndingCharOffset() throws XMLStreamException
- {
- return -1;
- }
-
- // // // and then the object-based access methods:
-
- public abstract XMLStreamLocation2 getStartLocation();
-
- public abstract XMLStreamLocation2 getCurrentLocation();
-
- public abstract XMLStreamLocation2 getEndLocation()
- throws XMLStreamException;
-
- /*
- ////////////////////////////////////////////////////
- // Stax2 validation
- ////////////////////////////////////////////////////
- */
-
- public XMLValidator validateAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- throwUnsupported();
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- throwUnsupported();
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidator validator)
- throws XMLStreamException
- {
- throwUnsupported();
- return null;
- }
-
- public abstract ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h);
-
- /*
- ////////////////////////////////////////////////////////
- // TypedXMLStreamReader, scalar elements
- ////////////////////////////////////////////////////////
- */
-
- public boolean getElementAsBoolean() throws XMLStreamException
- {
- ValueDecoderFactory.BooleanDecoder dec = _decoderFactory().getBooleanDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public int getElementAsInt() throws XMLStreamException
- {
- ValueDecoderFactory.IntDecoder dec = _decoderFactory().getIntDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public long getElementAsLong() throws XMLStreamException
- {
- ValueDecoderFactory.LongDecoder dec = _decoderFactory().getLongDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public float getElementAsFloat() throws XMLStreamException
- {
- ValueDecoderFactory.FloatDecoder dec = _decoderFactory().getFloatDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public double getElementAsDouble() throws XMLStreamException
- {
- ValueDecoderFactory.DoubleDecoder dec = _decoderFactory().getDoubleDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public BigInteger getElementAsInteger() throws XMLStreamException
- {
- ValueDecoderFactory.IntegerDecoder dec = _decoderFactory().getIntegerDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public BigDecimal getElementAsDecimal() throws XMLStreamException
- {
- ValueDecoderFactory.DecimalDecoder dec = _decoderFactory().getDecimalDecoder();
- getElementAs(dec);
- return dec.getValue();
- }
-
- public QName getElementAsQName() throws XMLStreamException
- {
- ValueDecoderFactory.QNameDecoder dec = _decoderFactory().getQNameDecoder(getNamespaceContext());
- getElementAs(dec);
- // !!! Should we try to verify validity of name chars?
- return dec.getValue();
- }
-
- public byte[] getElementAsBinary() throws XMLStreamException
- {
- return getElementAsBinary(Base64Variants.getDefaultVariant());
- }
-
- // !!! TODO: copy code from Stax2ReaderAdapter?
- public abstract byte[] getElementAsBinary(Base64Variant v) throws XMLStreamException;
-
- public void getElementAs(TypedValueDecoder tvd) throws XMLStreamException
- {
- String value = getElementText();
- try {
- tvd.decode(value);
- } catch (IllegalArgumentException iae) {
- throw _constructTypeException(iae, value);
- }
- }
-
- /*
- ////////////////////////////////////////////////////////
- // TypedXMLStreamReader2 implementation, array elements
- ////////////////////////////////////////////////////////
- */
-
- public int readElementAsIntArray(int[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getIntArrayDecoder(value, from, length));
- }
-
- public int readElementAsLongArray(long[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getLongArrayDecoder(value, from, length));
- }
-
- public int readElementAsFloatArray(float[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getFloatArrayDecoder(value, from, length));
- }
-
- public int readElementAsDoubleArray(double[] value, int from, int length) throws XMLStreamException
- {
- return readElementAsArray(_decoderFactory().getDoubleArrayDecoder(value, from, length));
- }
-
- /**
- * Actual implementation needs to implement tokenization and state
- * keeping.
- *lexical
had at least one
- * non-space character; null otherwise
- */
- public static String trimSpaces(String lexical)
- {
- int end = lexical.length();
- int start = 0;
-
- while (true) {
- if (start >= end) {
- return null;
- }
- if (!_isSpace(lexical.charAt(start))) {
- break;
- }
- ++start;
- }
- // No trailing space? Either original String as is, or just trim leading
- --end;
- if (!_isSpace(lexical.charAt(end))) {
- return (start == 0) ? lexical : lexical.substring(start);
- }
-
- // Otherwise, at least some trailing ws...
- while (--end > start && _isSpace(lexical.charAt(end))) { }
-
- return lexical.substring(start, end+1);
- }
-
- /**
- *StringBuilder
instead.
- */
- private StringBuffer mBuilder = null;
-
- public TextBuffer() { }
-
- public void reset()
- {
- mText = null;
- mBuilder = null;
- }
-
- public void append(String text)
- {
- int len = text.length();
- if (len > 0) {
- // Any prior text?
- if (mText != null) {
- mBuilder = new StringBuffer(mText.length() + len);
- mBuilder.append(mText);
- mText = null;
- }
- if (mBuilder != null) {
- mBuilder.append(text);
- } else {
- mText = text;
- }
- }
- }
-
- public String get()
- {
- if (mText != null) {
- return mText;
- }
- if (mBuilder != null) {
- return mBuilder.toString();
- }
- return "";
- }
-
- public boolean isEmpty() { return (mText == null) && (mBuilder == null); }
- }
-
- /**
- * Helper class for efficiently reading and aggregating variable length
- * byte content.
- */
- public final static class ByteAggregator
- {
- private final static byte[] NO_BYTES = new byte[0];
-
- /**
- * Size of the first block we will allocate.
- */
- private final static int INITIAL_BLOCK_SIZE = 500;
-
- /**
- * Maximum block size we will use for individual non-aggregated
- * blocks. Let's limit to using 256k chunks.
- */
- //private final static int MAX_BLOCK_SIZE = (1 << 18);
-
- final static int DEFAULT_BLOCK_ARRAY_SIZE = 100;
-
- private byte[][] mBlocks;
-
- private int mBlockCount;
-
- private int mTotalLen;
-
- /**
- * Reusable byte buffer block; we retain biggest one from
- * {@link #mBlocks} after aggregation.
- */
- private byte[] mSpareBlock;
-
- public ByteAggregator() { }
-
- /**
- * Method called to initialize aggregation process.
- *
- * @return Block that can be used to read in content
- */
- public byte[] startAggregation()
- {
- mTotalLen = 0;
- mBlockCount = 0;
- byte[] result = mSpareBlock;
- if (result == null) {
- result = new byte[INITIAL_BLOCK_SIZE];
- } else {
- mSpareBlock = null;
- }
- return result;
- }
-
- /**
- * Method used to add bufferful of data to the aggregator, and
- * get another buffer to read more data into. Returned buffer
- * is generally as big as or bigger than the given buffer, to try
- * to improve performance for larger aggregations.
- *
- * @return Buffer in which to read additional data
- */
- public byte[] addFullBlock(byte[] block)
- {
- int blockLen = block.length;
-
- if (mBlocks == null) {
- mBlocks = new byte[DEFAULT_BLOCK_ARRAY_SIZE][];
- } else {
- int oldLen = mBlocks.length;
- if (mBlockCount >= oldLen) {
- byte[][] old = mBlocks;
- mBlocks = new byte[oldLen + oldLen][];
- System.arraycopy(old, 0, mBlocks, 0, oldLen);
- }
- }
- mBlocks[mBlockCount] = block;
- ++mBlockCount;
- mTotalLen += blockLen;
-
- /* Let's allocate block that's half the total size, except
- * never smaller than twice the initial block size.
- * The idea is just to grow with reasonable rate, to optimize
- * between minimal number of chunks and minimal amount of
- * wasted space.
- */
- int newSize = Math.max((mTotalLen >> 1), (INITIAL_BLOCK_SIZE + INITIAL_BLOCK_SIZE));
- return new byte[newSize];
- }
-
- /**
- * Method called when results are finalized and we can get the
- * full aggregated result buffer to return to the caller
- */
- public byte[] aggregateAll(byte[] lastBlock, int lastLen)
- {
- int totalLen = mTotalLen + lastLen;
-
- if (totalLen == 0) { // quick check: nothing aggregated?
- return NO_BYTES;
- }
-
- byte[] result = new byte[totalLen];
- int offset = 0;
-
- if (mBlocks != null) {
- for (int i = 0; i < mBlockCount; ++i) {
- byte[] block = mBlocks[i];
- int len = block.length;
- System.arraycopy(block, 0, result, offset, len);
- offset += len;
- }
- }
- System.arraycopy(lastBlock, 0, result, offset, lastLen);
- // can reuse the last block: should be the biggest one we've handed
- mSpareBlock = lastBlock;
- offset += lastLen;
- if (offset != totalLen) { // just a sanity check
- throw new RuntimeException("Internal error: total len assumed to be "+totalLen+", copied "+offset+" bytes");
- }
- return result;
- }
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2WriterAdapter.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2WriterAdapter.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2WriterAdapter.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2WriterAdapter.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,633 +0,0 @@
-/* Stax2 API extension for Streaming Api for Xml processing (StAX).
- *
- * Copyright (c) 2006- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.codehaus.stax2.ri;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.namespace.QName;
-import javax.xml.stream.*;
-
-import org.codehaus.stax2.*;
-import org.codehaus.stax2.ri.typed.SimpleValueEncoder;
-import org.codehaus.stax2.typed.Base64Variant;
-import org.codehaus.stax2.typed.Base64Variants;
-// Not from Stax 1.0, but Stax2 does provide it:
-import org.codehaus.stax2.util.StreamWriterDelegate;
-import org.codehaus.stax2.validation.ValidationProblemHandler;
-import org.codehaus.stax2.validation.XMLValidationSchema;
-import org.codehaus.stax2.validation.XMLValidator;
-
-/**
- * This adapter implements parts of {@link XMLStreamWriter2}, the
- * extended stream writer defined by Stax2 extension, by wrapping
- * a vanilla Stax 1.0 {@link XMLStreamReader} implementation.
- *
- *
- */
-public class Stax2WriterAdapter
- extends StreamWriterDelegate
- implements XMLStreamWriter2 /* From Stax2 */
- ,XMLStreamConstants
-{
- /**
- * Encoding we have determined to be used, according to method
- * calls (write start document etc.)
- */
- protected String mEncoding;
-
- protected SimpleValueEncoder mValueEncoder;
-
- protected final boolean mNsRepairing;
-
- /*
- ////////////////////////////////////////////////////
- // Life-cycle methods
- ////////////////////////////////////////////////////
- */
-
- protected Stax2WriterAdapter(XMLStreamWriter sw)
- {
- super(sw);
- mDelegate = sw;
- Object value = sw.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
- mNsRepairing = (value instanceof Boolean) && ((Boolean) value).booleanValue();
- }
-
- /**
- * Method that should be used to add dynamic support for
- * {@link XMLStreamWriter2}. Method will check whether the
- * stream reader passed happens to be a {@link XMLStreamWriter2};
- * and if it is, return it properly cast. If not, it will create
- * necessary wrapper to support features needed by StaxMate,
- * using vanilla Stax 1.0 interface.
- */
- public static XMLStreamWriter2 wrapIfNecessary(XMLStreamWriter sw)
- {
- if (sw instanceof XMLStreamWriter2) {
- return (XMLStreamWriter2) sw;
- }
- return new Stax2WriterAdapter(sw);
- }
-
- /*
- /////////////////////////////////////////////////
- // TypedXMLStreamWriter2 implementation
- // (Typed Access API, Stax v3.0)
- /////////////////////////////////////////////////
- */
-
- // // // Typed element content write methods
-
- public void writeBoolean(boolean b) throws XMLStreamException
- {
- mDelegate.writeCharacters(b ? "true" : "false");
- }
-
- public void writeInt(int value) throws XMLStreamException
- {
- mDelegate.writeCharacters(String.valueOf(value));
- }
-
- public void writeLong(long value) throws XMLStreamException
- {
- mDelegate.writeCharacters(String.valueOf(value));
- }
-
- public void writeFloat(float value) throws XMLStreamException
- {
- mDelegate.writeCharacters(String.valueOf(value));
- }
-
- public void writeDouble(double value) throws XMLStreamException
- {
- mDelegate.writeCharacters(String.valueOf(value));
- }
-
- public void writeInteger(BigInteger value) throws XMLStreamException
- {
- mDelegate.writeCharacters(value.toString());
- }
-
- public void writeDecimal(BigDecimal value) throws XMLStreamException
- {
- mDelegate.writeCharacters(value.toString());
- }
-
- public void writeQName(QName name) throws XMLStreamException
- {
- mDelegate.writeCharacters(serializeQNameValue(name));
- }
-
- public void writeIntArray(int[] value, int from, int length)
- throws XMLStreamException
- {
- mDelegate.writeCharacters(getValueEncoder().encodeAsString(value, from, length));
- }
-
- public void writeLongArray(long[] value, int from, int length)
- throws XMLStreamException
- {
- mDelegate.writeCharacters(getValueEncoder().encodeAsString(value, from, length));
- }
-
- public void writeFloatArray(float[] value, int from, int length)
- throws XMLStreamException
- {
- mDelegate.writeCharacters(getValueEncoder().encodeAsString(value, from, length));
- }
-
- public void writeDoubleArray(double[] value, int from, int length)
- throws XMLStreamException
- {
- mDelegate.writeCharacters(getValueEncoder().encodeAsString(value, from, length));
- }
-
- public void writeBinary(Base64Variant v, byte[] value, int from, int length)
- throws XMLStreamException
- {
- mDelegate.writeCharacters(getValueEncoder().encodeAsString(v, value, from, length));
- }
-
- public void writeBinary(byte[] value, int from, int length)
- throws XMLStreamException
- {
- writeBinary(Base64Variants.getDefaultVariant(), value, from, length);
- }
-
- // // // Typed attribute value write methods
-
- public void writeBooleanAttribute(String prefix, String nsURI, String localName, boolean b) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName, b ? "true" : "false");
- }
-
- public void writeIntAttribute(String prefix, String nsURI, String localName, int value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName, String.valueOf(value));
- }
-
- public void writeLongAttribute(String prefix, String nsURI, String localName, long value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName, String.valueOf(value));
- }
-
- public void writeFloatAttribute(String prefix, String nsURI, String localName, float value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName, String.valueOf(value));
- }
-
- public void writeDoubleAttribute(String prefix, String nsURI, String localName, double value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName, String.valueOf(value));
- }
-
- public void writeIntegerAttribute(String prefix, String nsURI, String localName, BigInteger value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName, value.toString());
- }
-
- public void writeDecimalAttribute(String prefix, String nsURI, String localName, BigDecimal value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName, value.toString());
- }
-
- public void writeQNameAttribute(String prefix, String nsURI, String localName, QName name) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName, serializeQNameValue(name));
- }
-
- public void writeIntArrayAttribute(String prefix, String nsURI, String localName, int[] value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(value, 0, value.length));
- }
-
- public void writeLongArrayAttribute(String prefix, String nsURI, String localName, long[] value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(value, 0, value.length));
- }
-
- public void writeFloatArrayAttribute(String prefix, String nsURI, String localName, float[] value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(value, 0, value.length));
- }
-
- public void writeDoubleArrayAttribute(String prefix, String nsURI, String localName, double[] value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(value, 0, value.length));
- }
-
- public void writeBinaryAttribute(String prefix, String nsURI, String localName, byte[] value) throws XMLStreamException
- {
- writeBinaryAttribute(Base64Variants.getDefaultVariant(), prefix, nsURI, localName, value);
- }
-
- public void writeBinaryAttribute(Base64Variant v, String prefix, String nsURI, String localName, byte[] value) throws XMLStreamException
- {
- mDelegate.writeAttribute(prefix, nsURI, localName,
- getValueEncoder().encodeAsString(v, value, 0, value.length));
- }
-
- /*
- ////////////////////////////////////////////////////
- // XMLStreamWriter2 (StAX2) implementation
- ////////////////////////////////////////////////////
- */
-
- public boolean isPropertySupported(String name)
- {
- /* No real clean way to check this, so let's just fake by
- * claiming nothing is supported
- */
- return false;
- }
-
- public boolean setProperty(String name, Object value)
- {
- throw new IllegalArgumentException("No settable property '"+name+"'");
- }
-
- public XMLStreamLocation2 getLocation()
- {
- // No easy way to keep track of it, without impl support
- return null;
- }
-
- public String getEncoding()
- {
- // We may have been able to infer it... if so:
- return mEncoding;
- }
-
- public void writeCData(char[] text, int start, int len)
- throws XMLStreamException
- {
- writeCData(new String(text, start, len));
- }
-
- public void writeDTD(String rootName, String systemId, String publicId,
- String internalSubset)
- throws XMLStreamException
- {
- /* This may or may not work... depending on how well underlying
- * implementation follows stax 1.0 spec (it should work)
- */
- StringBuffer sb = new StringBuffer();
- sb.append(" 0) {
- sb.append(" [");
- sb.append(internalSubset);
- sb.append(']');
- }
- sb.append('>');
- writeDTD(sb.toString());
- }
-
- public void writeFullEndElement()
- throws XMLStreamException
- {
- /* It may be possible to fake it, by pretending to write
- * character output, which in turn should prevent writing of
- * an empty element...
- */
- mDelegate.writeCharacters("");
- mDelegate.writeEndElement();
- }
-
- public void writeSpace(String text)
- throws XMLStreamException
- {
- /* Hmmh. Two choices: either try to write as regular characters,
- * or output as is via raw calls. Latter would be safer, if we
- * had access to it; former may escape incorrectly.
- * While this may not be optimal, let's try former
- */
- writeRaw(text);
- }
-
- public void writeSpace(char[] text, int offset, int length)
- throws XMLStreamException
- {
- // See comments above...
- writeRaw(text, offset, length);
- }
-
- public void writeStartDocument(String version, String encoding,
- boolean standAlone)
- throws XMLStreamException
- {
- // No good way to do it, so let's do what we can...
- writeStartDocument(encoding, version);
- }
-
- /*
- ///////////////////////////////
- // Stax2, Pass-through methods
- ///////////////////////////////
- */
-
- public void writeRaw(String text)
- throws XMLStreamException
- {
- writeRaw(text, 0, text.length());
- }
-
- public void writeRaw(String text, int offset, int len)
- throws XMLStreamException
- {
- // There is no clean way to implement this via Stax 1.0, alas...
- throw new UnsupportedOperationException("Not implemented");
- }
-
- public void writeRaw(char[] text, int offset, int length)
- throws XMLStreamException
- {
- writeRaw(new String(text, offset, length));
- }
-
- public void copyEventFromReader(XMLStreamReader2 sr, boolean preserveEventData)
- throws XMLStreamException
- {
- switch (sr.getEventType()) {
- case START_DOCUMENT:
- {
- String version = sr.getVersion();
- /* No real declaration? If so, we don't want to output
- * anything, to replicate as closely as possible the
- * source document
- */
- if (version == null || version.length() == 0) {
- ; // no output if no real input
- } else {
- if (sr.standaloneSet()) {
- writeStartDocument(sr.getVersion(),
- sr.getCharacterEncodingScheme(),
- sr.isStandalone());
- } else {
- writeStartDocument(sr.getCharacterEncodingScheme(),
- sr.getVersion());
- }
- }
- }
- return;
-
- case END_DOCUMENT:
- writeEndDocument();
- return;
-
- // Element start/end events:
- case START_ELEMENT:
- /* Start element is bit trickier to output since there
- * may be differences between repairing/non-repairing
- * writers. But let's try a generic handling here.
- */
- copyStartElement(sr);
- return;
-
- case END_ELEMENT:
- writeEndElement();
- return;
-
- case SPACE:
- writeSpace(sr.getTextCharacters(), sr.getTextStart(), sr.getTextLength());
- return;
-
- case CDATA:
- writeCData(sr.getTextCharacters(), sr.getTextStart(), sr.getTextLength());
- return;
-
- case CHARACTERS:
- writeCharacters(sr.getTextCharacters(), sr.getTextStart(), sr.getTextLength());
- return;
-
- case COMMENT:
- writeComment(sr.getText());
- return;
-
- case PROCESSING_INSTRUCTION:
- writeProcessingInstruction(sr.getPITarget(), sr.getPIData());
- return;
-
- case DTD:
- {
- DTDInfo info = sr.getDTDInfo();
- if (info == null) {
- /* Hmmmh. Can this happen for non-DTD-aware readers?
- * And if so, what should we do?
- */
- throw new XMLStreamException("Current state DOCTYPE, but not DTDInfo Object returned -- reader doesn't support DTDs?");
- }
- writeDTD(info.getDTDRootName(), info.getDTDSystemId(),
- info.getDTDPublicId(), info.getDTDInternalSubset());
- }
- return;
-
- case ENTITY_REFERENCE:
- writeEntityRef(sr.getLocalName());
- return;
-
- case ATTRIBUTE:
- case NAMESPACE:
- case ENTITY_DECLARATION:
- case NOTATION_DECLARATION:
- // Let's just fall back to throw the exception
- }
- throw new XMLStreamException("Unrecognized event type ("
- +sr.getEventType()+"); not sure how to copy");
- }
-
- /*
- ///////////////////////////////
- // Stax2, output handling
- ///////////////////////////////
- */
-
- public void closeCompletely() throws XMLStreamException
- {
- /* 06-Nov-2008, TSa: alas, there is no way to properly implement
- * this. Should we throw an exception? For now, let's just call
- * regular close; not quite the same, but better than nothing
- */
- close();
- }
-
- /*
- ///////////////////////////////
- // Stax2, validation
- ///////////////////////////////
- */
-
- public XMLValidator validateAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- // !!! TODO: try to implement?
- throw new UnsupportedOperationException("Not yet implemented");
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidator validator)
- throws XMLStreamException
- {
- return null;
- }
-
- public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
- {
- /* Not a real problem: although we can't do anything with it
- * (without real validator integration)
- */
- return null;
- }
-
- /*
- ///////////////////////////////
- // Helper methods
- ///////////////////////////////
- */
-
- protected void copyStartElement(XMLStreamReader sr)
- throws XMLStreamException
- {
- // Any namespace declarations/bindings?
- int nsCount = sr.getNamespaceCount();
- if (nsCount > 0) { // yup, got some...
- /* First, need to (or at least, should?) add prefix bindings:
- * (may not be 100% required, but probably a good thing to do,
- * just so that app code has access to prefixes then)
- */
- for (int i = 0; i < nsCount; ++i) {
- String prefix = sr.getNamespacePrefix(i);
- String uri = sr.getNamespaceURI(i);
- if (prefix == null || prefix.length() == 0) { // default NS
- setDefaultNamespace(uri);
- } else {
- setPrefix(prefix, uri);
- }
- }
- }
- writeStartElement(sr.getPrefix(), sr.getLocalName(), sr.getNamespaceURI());
-
- if (nsCount > 0) {
- // And then output actual namespace declarations:
- for (int i = 0; i < nsCount; ++i) {
- String prefix = sr.getNamespacePrefix(i);
- String uri = sr.getNamespaceURI(i);
-
- if (prefix == null || prefix.length() == 0) { // default NS
- writeDefaultNamespace(uri);
- } else {
- writeNamespace(prefix, uri);
- }
- }
- }
-
- /* And then let's just output attributes. But should we copy the
- * implicit attributes (created via attribute defaulting?)
- */
- int attrCount = sr.getAttributeCount();
- if (attrCount > 0) {
- for (int i = 0; i < attrCount; ++i) {
- writeAttribute(sr.getAttributePrefix(i),
- sr.getAttributeNamespace(i),
- sr.getAttributeLocalName(i),
- sr.getAttributeValue(i));
- }
- }
- }
-
- /**
- * Method called to serialize given qualified name into valid
- * String serialization, taking into account existing namespace
- * bindings.
- */
- protected String serializeQNameValue(QName name)
- throws XMLStreamException
- {
- String prefix;
- // Ok as is? In repairing mode need to ensure it's properly bound
- if (mNsRepairing) {
- String uri = name.getNamespaceURI();
- // First: let's see if a valid binding already exists:
- NamespaceContext ctxt = getNamespaceContext();
- prefix = (ctxt == null) ? null : ctxt.getPrefix(uri);
- if (prefix == null) {
- // nope: need to (try to) bind
- String origPrefix = name.getPrefix();
- if (origPrefix == null || origPrefix.length() == 0) {
- prefix = "";
- /* note: could cause a namespace conflict... but
- * there is nothing we can do with just stax1 stream
- * writer
- */
- writeDefaultNamespace(uri);
- } else {
- prefix = origPrefix;
- writeNamespace(prefix, uri);
- }
- }
- } else { // in non-repairing, good as is
- prefix = name.getPrefix();
- }
- String local = name.getLocalPart();
- if (prefix == null || prefix.length() == 0) {
- return local;
- }
-
- // Not efficient... but should be ok
- return prefix + ":" + local;
- }
-
- protected SimpleValueEncoder getValueEncoder()
- {
- if (mValueEncoder == null) {
- mValueEncoder = new SimpleValueEncoder();
- }
- return mValueEncoder;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2WriterImpl.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2WriterImpl.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/Stax2WriterImpl.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/Stax2WriterImpl.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,332 +0,0 @@
-/* Stax2 API extension for Streaming Api for Xml processing (StAX).
- *
- * Copyright (c) 2006- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.codehaus.stax2.ri;
-
-import javax.xml.stream.*;
-
-import org.codehaus.stax2.*;
-import org.codehaus.stax2.validation.*;
-
-/**
- * This is a partial base implementation of {@link XMLStreamWriter2},
- * the extended stream writer that is part of Stax2.
- */
-public abstract class Stax2WriterImpl
- implements XMLStreamWriter2 /* From Stax2 */
- ,XMLStreamConstants
-{
- /*
- ///////////////////////////////////////////////////////////
- // Life-cycle methods
- ///////////////////////////////////////////////////////////
- */
-
- protected Stax2WriterImpl() { }
-
- /*
- ///////////////////////////////////////////////////////////
- // XMLStreamWriter2 (StAX2) implementation
- ///////////////////////////////////////////////////////////
- */
-
- public boolean isPropertySupported(String name)
- {
- /* No base properties (or should we have something for impl
- * name, version?)
- */
- return false;
- }
-
- public boolean setProperty(String name, Object value)
- {
- throw new IllegalArgumentException("No settable property '"+name+"'");
- }
-
- public abstract XMLStreamLocation2 getLocation();
-
- public abstract String getEncoding();
-
- public void writeCData(char[] text, int start, int len)
- throws XMLStreamException
- {
- writeCData(new String(text, start, len));
- }
-
- public void writeDTD(String rootName, String systemId, String publicId,
- String internalSubset)
- throws XMLStreamException
- {
- /* This may or may not work... depending on how well underlying
- * implementation follows stax 1.0 spec (it should work)
- */
- StringBuffer sb = new StringBuffer();
- sb.append(" 0) {
- sb.append(" [");
- sb.append(internalSubset);
- sb.append(']');
- }
- sb.append('>');
- writeDTD(sb.toString());
- }
-
- public void writeFullEndElement()
- throws XMLStreamException
- {
- /* This should work with base Stax 1.0 implementations.
- * Sub-classes are, however, encouraged to implement it
- * more directly, if possible.
- */
- writeCharacters("");
- writeEndElement();
- }
-
- public void writeSpace(String text)
- throws XMLStreamException
- {
- /* Hmmh. Two choices: either try to write as regular characters,
- * or output as is via raw calls. Latter would be safer, if we
- * had access to it; former may escape incorrectly.
- * While this may not be optimal, let's try former
- */
- writeRaw(text);
- }
-
- public void writeSpace(char[] text, int offset, int length)
- throws XMLStreamException
- {
- // See comments above...
- writeRaw(text, offset, length);
- }
-
- public abstract void writeStartDocument(String version, String encoding,
- boolean standAlone)
- throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // Stax2, Pass-through methods
- ///////////////////////////////////////////////////////////
- */
-
- public void writeRaw(String text)
- throws XMLStreamException
- {
- writeRaw(text, 0, text.length());
- }
-
- public abstract void writeRaw(String text, int offset, int len)
- throws XMLStreamException;
-
- public abstract void writeRaw(char[] text, int offset, int length)
- throws XMLStreamException;
-
- public void copyEventFromReader(XMLStreamReader2 sr, boolean preserveEventData)
- throws XMLStreamException
- {
- switch (sr.getEventType()) {
- case START_DOCUMENT:
- {
- String version = sr.getVersion();
- /* No real declaration? If so, we don't want to output
- * anything, to replicate as closely as possible the
- * source document
- */
- if (version == null || version.length() == 0) {
- ; // no output if no real input
- } else {
- if (sr.standaloneSet()) {
- writeStartDocument(sr.getVersion(),
- sr.getCharacterEncodingScheme(),
- sr.isStandalone());
- } else {
- writeStartDocument(sr.getCharacterEncodingScheme(),
- sr.getVersion());
- }
- }
- }
- return;
-
- case END_DOCUMENT:
- writeEndDocument();
- return;
-
- // Element start/end events:
- case START_ELEMENT:
- /* Start element is bit trickier to output since there
- * may be differences between repairing/non-repairing
- * writers. But let's try a generic handling here.
- */
- copyStartElement(sr);
- return;
-
- case END_ELEMENT:
- writeEndElement();
- return;
-
- case SPACE:
- writeSpace(sr.getTextCharacters(), sr.getTextStart(), sr.getTextLength());
- return;
-
- case CDATA:
- writeCData(sr.getTextCharacters(), sr.getTextStart(), sr.getTextLength());
- return;
-
- case CHARACTERS:
- writeCharacters(sr.getTextCharacters(), sr.getTextStart(), sr.getTextLength());
- return;
-
- case COMMENT:
- writeComment(sr.getText());
- return;
-
- case PROCESSING_INSTRUCTION:
- writeProcessingInstruction(sr.getPITarget(), sr.getPIData());
- return;
-
- case DTD:
- {
- DTDInfo info = sr.getDTDInfo();
- if (info == null) {
- /* Hmmmh. Can this happen for non-DTD-aware readers?
- * And if so, what should we do?
- */
- throw new XMLStreamException("Current state DOCTYPE, but not DTDInfo Object returned -- reader doesn't support DTDs?");
- }
- writeDTD(info.getDTDRootName(), info.getDTDSystemId(),
- info.getDTDPublicId(), info.getDTDInternalSubset());
- }
- return;
-
- case ENTITY_REFERENCE:
- writeEntityRef(sr.getLocalName());
- return;
-
- case ATTRIBUTE:
- case NAMESPACE:
- case ENTITY_DECLARATION:
- case NOTATION_DECLARATION:
- // Let's just fall back to throw the exception
- }
- throw new XMLStreamException("Unrecognized event type ("
- +sr.getEventType()+"); not sure how to copy");
- }
-
- /*
- ///////////////////////////////////////////////////////////
- // Stax2, validation
- ///////////////////////////////////////////////////////////
- */
-
- public XMLValidator validateAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- throw new UnsupportedOperationException("Not yet implemented");
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
- throws XMLStreamException
- {
- return null;
- }
-
- public XMLValidator stopValidatingAgainst(XMLValidator validator)
- throws XMLStreamException
- {
- return null;
- }
-
- public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
- {
- /* Not a real problem: although we can't do anything with it
- * (without real validator integration)
- */
- return null;
- }
-
- /*
- ///////////////////////////////////////////////////////////
- // Helper methods
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Basic implementation of copy operation. It is likely that
- * sub-classes can implement more efficient copy operations: if so,
- * they should do so.
- */
- protected void copyStartElement(XMLStreamReader sr)
- throws XMLStreamException
- {
- // Any namespace declarations/bindings?
- int nsCount = sr.getNamespaceCount();
- if (nsCount > 0) { // yup, got some...
- /* First, need to (or at least, should?) add prefix bindings:
- * (may not be 100% required, but probably a good thing to do,
- * just so that app code has access to prefixes then)
- */
- for (int i = 0; i < nsCount; ++i) {
- String prefix = sr.getNamespacePrefix(i);
- String uri = sr.getNamespaceURI(i);
- if (prefix == null || prefix.length() == 0) { // default NS
- setDefaultNamespace(uri);
- } else {
- setPrefix(prefix, uri);
- }
- }
- }
- writeStartElement(sr.getPrefix(), sr.getLocalName(), sr.getNamespaceURI());
-
- if (nsCount > 0) {
- // And then output actual namespace declarations:
- for (int i = 0; i < nsCount; ++i) {
- String prefix = sr.getNamespacePrefix(i);
- String uri = sr.getNamespaceURI(i);
-
- if (prefix == null || prefix.length() == 0) { // default NS
- writeDefaultNamespace(uri);
- } else {
- writeNamespace(prefix, uri);
- }
- }
- }
-
- /* And then let's just output attributes. But should we copy the
- * implicit attributes (created via attribute defaulting?)
- */
- int attrCount = sr.getAttributeCount();
- if (attrCount > 0) {
- for (int i = 0; i < attrCount; ++i) {
- writeAttribute(sr.getAttributePrefix(i),
- sr.getAttributeNamespace(i),
- sr.getAttributeLocalName(i),
- sr.getAttributeValue(i));
- }
- }
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/AsciiValueEncoder.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/AsciiValueEncoder.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/AsciiValueEncoder.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/AsciiValueEncoder.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,133 +0,0 @@
-/* Reference Implementation of
- * Stax2 extension API (for basic Stax API, JSR-173)
- *
- * Copyright (c) 2008- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.typed;
-
-/**
- * This base class defines interface used for efficient encoding
- * of typed values, by stream writers. The abstraction is necessary
- * to reduce amount of duplicated code while avoiding significant
- * additional overhead. The idea is that the low-level stream
- * writer backend supplies encoder with the result buffer, while
- * encoder itself knows the data and state. Together these allow
- * for efficient serialization with light coupling.
- *
- *
- *MIN_CHARS_WITHOUT_FLUSH)
- *
- *
- */
- public final int endOfContent()
- {
- // If we are in a state where we don't have partial triplet, we are good to go
- if ((_state == STATE_INITIAL) || (_state == STATE_OUTPUT_3)
- || (_state == STATE_OUTPUT_2) || (_state == STATE_OUTPUT_1)) {
- return 0;
- }
- // Otherwise, only ok if no padding is used
- if (_variant.usesPadding()) {
- return -1;
- }
-
- // We do have 2 possible valid incomplete states
- if (_state == STATE_VALID_2) { // 2 chars -> 1 output byte
- // Got 12 bits, only need 8, need to shift
- _state = STATE_OUTPUT_1;
- _decodedData >>= 4;
- return 1;
- } else if (_state == STATE_VALID_3) { // 3 chars -> 2 output bytes
- // Got 18 bits, of which 16 data
- _decodedData >>= 2;
- _state = STATE_OUTPUT_2;
- return 2;
- } else { // other states either handled, or can not be valid terminal states (STATE_VALID1)
- return -1;
- }
- }
-
- /*
- //////////////////////////////////////////////////////////////
- // Convenience accessors
- //////////////////////////////////////////////////////////////
- */
-
- /**
- * Method that can be called to completely decode content that this
- * decoder has been initialized with.
- */
- public byte[] decodeCompletely()
- {
- Stax2Util.ByteAggregator aggr = getByteAggregator();
- byte[] buffer = aggr.startAggregation();
- while (true) {
- // Ok let's read full buffers each round
- int offset = 0;
- int len = buffer.length;
-
- do {
- int readCount = decode(buffer, offset, len);
- // note: can return 0; converted to -1 by front-end
- if (readCount < 1) { // all done!
- // but we must be in a valid state too:
- /* Just need to verify we don't have partial stuff
- * (missing one to three characters of a full quartet
- * that encodes 1 - 3 bytes). Also: non-padding
- * variants can be in incomplete state, from which
- * data may need to be flushed...
- */
- int left = endOfContent();
- if (left < 0) { // incomplete, error
- throw new IllegalArgumentException("Incomplete base64 triplet at the end of decoded content");
- } else if (left > 0) { // 1 or 2 more bytes of data to add
- continue;
- }
- return aggr.aggregateAll(buffer, offset);
- }
- offset += readCount;
- len -= readCount;
- } while (len > 0);
-
- // and if we got it, hand out results, get a new buffer
- buffer = aggr.addFullBlock(buffer);
- }
- }
-
- public Stax2Util.ByteAggregator getByteAggregator()
- {
- if (_byteAggr == null) {
- _byteAggr = new Stax2Util.ByteAggregator();
- }
- return _byteAggr;
- }
-
- /*
- //////////////////////////////////////////////////////////////
- // Internal helper methods error reporting
- //////////////////////////////////////////////////////////////
- */
-
- protected IllegalArgumentException reportInvalidChar(char ch, int bindex)
- throws IllegalArgumentException
- {
- return reportInvalidChar(ch, bindex, null);
- }
-
- /**
- * @param bindex Relative index within base64 character unit; between 0
- * and 3 (as unit has exactly 4 characters)
- */
- protected IllegalArgumentException reportInvalidChar(char ch, int bindex, String msg)
- throws IllegalArgumentException
- {
- String base;
- if (ch <= INT_SPACE) {
- base = "Illegal white space character (code 0x"+Integer.toHexString(ch)+") as character #"+(bindex+1)+" of 4-char base64 unit: can only used between units";
- } else if (_variant.usesPaddingChar(ch)) {
- base = "Unexpected padding character ('"+_variant.getPaddingChar()+"') as character #"+(bindex+1)+" of 4-char base64 unit: padding only legal as 3rd or 4th character";
- } else if (!Character.isDefined(ch) || Character.isISOControl(ch)) {
- // Not sure if we can really get here... ? (most illegal xml chars are caught at lower level)
- base = "Illegal character (code 0x"+Integer.toHexString(ch)+") in base64 content";
- } else {
- base = "Illegal character '"+((char)ch)+"' (code 0x"+Integer.toHexString(ch)+") in base64 content";
- }
- if (msg != null) {
- base = base + ": " + msg;
- }
- return new IllegalArgumentException(base);
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/CharArrayBase64Decoder.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/CharArrayBase64Decoder.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/CharArrayBase64Decoder.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/CharArrayBase64Decoder.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,272 +0,0 @@
-/* StAX2 extension for StAX API (JSR-173).
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.typed;
-
-import java.util.*;
-
-import org.codehaus.stax2.typed.Base64Variant;
-
-/**
- * Base64 decoder that can be used to decode base64 encoded content that
- * is passed as char arrays.
- */
-public final class CharArrayBase64Decoder
- extends Base64DecoderBase
-{
- // // // Input buffer information
-
- /**
- * Text segment being currently processed.
- */
- char[] _currSegment;
-
- int _currSegmentPtr;
- int _currSegmentEnd;
-
- final ArrayList _nextSegments = new ArrayList();
-
- int _lastSegmentOffset;
- int _lastSegmentEnd;
-
- /**
- * Pointer of the next segment to process (after current one stored
- * in {@link #_currSegment}) within {@link #mOtherSegments}.
- */
- int _nextSegmentIndex;
-
- public CharArrayBase64Decoder() { super(); }
-
- public void init(Base64Variant variant, boolean firstChunk,
- char[] lastSegment, int lastOffset, int lastLen,
- List segments)
- {
- _variant = variant;
- /* Leftovers only cleared if it is the first chunk (i.e.
- * right after START_ELEMENT)
- */
- if (firstChunk) {
- _state = STATE_INITIAL;
- }
- _nextSegments.clear();
- if (segments == null || segments.isEmpty()) { // no segments, simple
- _currSegment = lastSegment;
- _currSegmentPtr = lastOffset;
- _currSegmentEnd = lastOffset+lastLen;
- } else {
- if (lastSegment == null) { // sanity check
- throw new IllegalArgumentException();
- }
-
- Iterator it = segments.iterator();
- _currSegment = (char[]) it.next();
- _currSegmentPtr = 0;
- _currSegmentEnd = _currSegment.length;
-
- while (it.hasNext()) {
- _nextSegments.add(it.next());
- }
- _nextSegmentIndex = 0;
-
- // Plus, still need to add the last segment
- _nextSegments.add(lastSegment);
- _lastSegmentOffset = lastOffset;
- _lastSegmentEnd = lastOffset+lastLen;
- }
- }
-
- /**
- * @param resultBuffer Buffer in which decoded bytes are returned
- * @param resultOffset Offset that points to position to put the
- * first decoded byte in maxLength Maximum number of bytes that can be returned
- * in given buffer
- *
- * @return Number of bytes decoded and returned in the result buffer
- */
- public int decode(byte[] resultBuffer, int resultOffset, int maxLength)
- throws IllegalArgumentException
- {
- final int origResultOffset = resultOffset;
- final int resultBufferEnd = resultOffset + maxLength;
-
- main_loop:
- while (true) {
- switch (_state) {
- case STATE_INITIAL:
- // first, we'll skip preceding white space, if any
- {
- char ch;
- do {
- if (_currSegmentPtr >= _currSegmentEnd) {
- if (!nextSegment()) {
- break main_loop;
- }
- }
- ch = _currSegment[_currSegmentPtr++];
- } while (ch <= INT_SPACE);
- int bits = _variant.decodeBase64Char(ch);
- if (bits < 0) {
- throw reportInvalidChar(ch, 0);
- }
- _decodedData = bits;
- }
- // fall through, "fast" path
-
- case STATE_VALID_1:
- // then second base64 char; can't get padding yet, nor ws
- {
- if (_currSegmentPtr >= _currSegmentEnd) {
- if (!nextSegment()) {
- _state = STATE_VALID_1; // to cover fall-through case
- break main_loop;
- }
- }
- char ch = _currSegment[_currSegmentPtr++];
- int bits = _variant.decodeBase64Char(ch);
- if (bits < 0) {
- throw reportInvalidChar(ch, 1);
- }
- _decodedData = (_decodedData << 6) | bits;
- }
- // fall through, "fast path"
-
- case STATE_VALID_2:
- // third base64 char; can be padding, but not ws
- {
- if (_currSegmentPtr >= _currSegmentEnd) {
- if (!nextSegment()) {
- _state = STATE_VALID_2; // to cover fall-through case
- break main_loop;
- }
- }
- char ch = _currSegment[_currSegmentPtr++];
- int bits = _variant.decodeBase64Char(ch);
- if (bits < 0) {
- if (bits != Base64Variant.BASE64_VALUE_PADDING) {
- throw reportInvalidChar(ch, 2);
- }
- // Padding is off the "fast path", so:
- _state = STATE_VALID_2_AND_PADDING;
- continue main_loop;
- }
- _decodedData = (_decodedData << 6) | bits;
- }
- // fall through, "fast path"
-
- case STATE_VALID_3:
- // fourth and last base64 char; can be padding, but not ws
- {
- if (_currSegmentPtr >= _currSegmentEnd) {
- if (!nextSegment()) {
- _state = STATE_VALID_3; // to cover fall-through case
- break main_loop;
- }
- }
- char ch = _currSegment[_currSegmentPtr++];
- int bits = _variant.decodeBase64Char(ch);
- if (bits < 0) {
- if (bits != Base64Variant.BASE64_VALUE_PADDING) {
- throw reportInvalidChar(ch, 3);
- }
- /* With padding we only get 2 bytes; but we have
- * to shift it a bit so it is identical to triplet
- * case with partial output.
- * 3 chars gives 3x6 == 18 bits, of which 2 are
- * dummies, need to discard:
- */
- _decodedData >>= 2;
- _state = STATE_OUTPUT_2;
- continue main_loop;
- }
- // otherwise, our triple is now complete
- _decodedData = (_decodedData << 6) | bits;
- }
- // still along fast path
-
- case STATE_OUTPUT_3:
- if (resultOffset >= resultBufferEnd) { // no room
- _state = STATE_OUTPUT_3;
- break main_loop;
- }
- resultBuffer[resultOffset++] = (byte) (_decodedData >> 16);
- // fall through
-
- case STATE_OUTPUT_2:
- if (resultOffset >= resultBufferEnd) { // no room
- _state = STATE_OUTPUT_2;
- break main_loop;
- }
- resultBuffer[resultOffset++] = (byte) (_decodedData >> 8);
- // fall through
-
- case STATE_OUTPUT_1:
- if (resultOffset >= resultBufferEnd) { // no room
- _state = STATE_OUTPUT_1;
- break main_loop;
- }
- resultBuffer[resultOffset++] = (byte) _decodedData;
- _state = STATE_INITIAL;
- continue main_loop;
-
- case STATE_VALID_2_AND_PADDING:
- {
- if (_currSegmentPtr >= _currSegmentEnd) {
- if (!nextSegment()) {
- // must have valid state already (can't get in via fall-through)
- break main_loop;
- }
- }
- char ch = _currSegment[_currSegmentPtr++];
- if (!_variant.usesPaddingChar(ch)) {
- throw reportInvalidChar(ch, 3, "expected padding character '"+_variant.getPaddingChar()+"'");
- }
- // Got 12 bits, only need 8, need to shift
- _state = STATE_OUTPUT_1;
- _decodedData >>= 4;
- }
- continue main_loop;
-
- default:
- // sanity check: should never happen
- throw new IllegalStateException("Illegal internal state "+_state);
- }
- }
- return resultOffset - origResultOffset;
- }
-
- /*
- //////////////////////////////////////////////////////////////
- // Internal helper methods for input access:
- //////////////////////////////////////////////////////////////
- */
-
- private boolean nextSegment()
- {
- if (_nextSegmentIndex < _nextSegments.size()) {
- _currSegment = (char[]) _nextSegments.get(_nextSegmentIndex++);
- // last segment may have non-zero ptr, slack at end
- if (_nextSegmentIndex == _nextSegments.size()) {
- _currSegmentPtr = _lastSegmentOffset;
- _currSegmentEnd = _lastSegmentEnd;
- } else {
- _currSegmentPtr = 0;
- _currSegmentEnd = _currSegment.length;
- }
- return true;
- }
- return false;
- }
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/NumberUtil.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/NumberUtil.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/ri/typed/NumberUtil.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/ri/typed/NumberUtil.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,436 +0,0 @@
-/* StAX2 extension for StAX API (JSR-173).
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.ri.typed;
-
-/**
- * Helper class that contains method for converting numeric
- * values to and from String representations.
- */
-public final class NumberUtil
-{
- /**
- * Maximum number of characters in a serialized integer is
- * 11; one for (minus) sign, and then up to 10 digits
- */
- public final static int MAX_INT_CLEN = 11;
-
- /**
- * Maximum number of characters in a serialized long is
- * 21; one for (minus) sign, and then up to 20 digits
- */
- public final static int MAX_LONG_CLEN = 21;
-
- /**
- * Maximum number of characters in a serialized double is
- * 26 (at least for Sun JDK; 19 digits for mantissa, 3 for exponent,
- * signs for mantissa and exponent, decimal point, 'E'):
- * but let's pad it up a little bit just to play it safe.
- */
- public final static int MAX_DOUBLE_CLEN = 32;
-
- /**
- * JDK serializes floats same way as doubles, so let's
- * reserve as much space
- */
- public final static int MAX_FLOAT_CLEN = MAX_DOUBLE_CLEN;
-
- private final static char NULL_CHAR = (char) 0;
-
- private final static int MILLION = 1000000;
- private final static int BILLION = 1000000000;
- private final static long TEN_BILLION_L = 10000000000L;
- private final static long THOUSAND_L = 1000L;
-
- private final static byte BYTE_HYPHEN = (byte) '-';
- private final static byte BYTE_1 = (byte) '1';
- private final static byte BYTE_2 = (byte) '2';
-
- /**
- *
- *
- *
- * @author Tatu Saloranta
- *
- * @since 3.0.0
- */
-public final class Base64Variant
-{
- /**
- * Placeholder used by "no padding" variant, to be used when a character
- * value is needed.
- */
- final static char PADDING_CHAR_NONE = '\0';
-
- /**
- * Marker used to denote ascii characters that do not correspond
- * to a 6-bit value (in this variant), and is not used as a padding
- * character.
- */
- public final static int BASE64_VALUE_INVALID = -1;
-
- /**
- * Marker used to denote ascii character (in decoding table) that
- * is the padding character using this variant (if any).
- */
- public final static int BASE64_VALUE_PADDING = -2;
-
- /*
- ////////////////////////////////////////////////////
- // Encoding/decoding tables
- ////////////////////////////////////////////////////
- */
-
- /**
- * Decoding table used for base 64 decoding.
- */
- private final int[] _asciiToBase64 = new int[128];
-
- /**
- * Encoding table used for base 64 decoding when output is done
- * as characters.
- */
- private final char[] _base64ToAsciiC = new char[64];
-
- /**
- * Alternative encoding table used for base 64 decoding when output is done
- * as ascii bytes.
- */
- private final byte[] _base64ToAsciiB = new byte[64];
-
- /*
- ////////////////////////////////////////////////////
- // Other configuration
- ////////////////////////////////////////////////////
- */
-
- /**
- * Symbolic name of variant; used for diagnostics/debugging.
- */
- final String _name;
-
- /**
- * Whether this variant uses padding or not.
- */
- final boolean _usesPadding;
-
- /**
- * Characted used for padding, if any ({@link #PADDING_CHAR_NONE} if not).
- */
- final char _paddingChar;
-
- /**
- * Maximum number of encoded base64 characters to output during encoding
- * before adding a linefeed, if line length is to be limited
- * ({@link java.lang.Integer#MAX_VALUE} if not limited).
- *null
- * if a processor is unable to provide it. Lexical representation
- * should preferably be as close to the original input String
- * as possible (as opposed to being normalized which often
- * is done before actual parsing).
- */
- protected String mLexical;
-
- /**
- * Construct an exception with the associated message.
- *
- * @param msg The message to report.
- */
- public TypedXMLStreamException(String lexical, String msg)
- {
- super(msg);
- mLexical = lexical;
- }
-
- /**
- * Constructor used to wrap an underlying data conversion
- * error message.
- *
- * @param rootCause Underlying conversion problem
- */
- public TypedXMLStreamException(String lexical, IllegalArgumentException rootCause)
- {
- super(rootCause);
- mLexical = lexical;
- }
-
- /**
- * Construct an exception with the associated message and exception
- *
- * @param msg The message to report.
- * @param rootCause Underlying conversion problem
- */
- public TypedXMLStreamException(String lexical, String msg, IllegalArgumentException rootCause)
- {
- super(msg, rootCause);
- mLexical = lexical;
- }
-
- /**
- * Construct an exception with the associated message, exception and
- * location.
- *
- * @param msg The message to report.
- * @param location The location of the error.
- * @param rootCause Underlying conversion problem
- */
- public TypedXMLStreamException(String lexical, String msg,
- Location location,
- IllegalArgumentException rootCause)
- {
- super(msg, location, rootCause);
- mLexical = lexical;
- }
-
- /**
- * Construct an exception with the associated message, exception and
- * location.
- *
- * @param msg The message to report.
- * @param location The location of the error.
- */
- public TypedXMLStreamException(String lexical, String msg,
- Location location)
- {
- super(msg, location);
- mLexical = lexical;
- }
-
- /**
- * Return the lexical representation of the attribute or element
- * content that could not be converted as requested.
- *
- * @return Lexical representation of unconverted content or
- * null
if unavailable.
- */
- public String getLexical() {
- return mLexical;
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamReader.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamReader.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamReader.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamReader.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,593 +0,0 @@
-/* Stax2 extension for basic Stax API (JSR-173).
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2.typed;
-
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamReader;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import javax.xml.namespace.QName;
-
-// !!! 30-Jan-2008, TSa: JDK 1.5 only, can't add yet
-//import javax.xml.datatype.XMLGregorianCalendar;
-
-/**
- * This interface provides a typed extension to
- * {@link javax.xml.stream.XMLStreamReader}. It defines methods for
- * reading XML data and converting it into Java types.
- *
- * @author Santiago.PericasGeertsen@sun.com
- * @author Tatu Saloranta
- *
- * @since 3.0
- */
-public interface TypedXMLStreamReader
- extends XMLStreamReader
-{
- /*
- //////////////////////////////////////////////////////////
- // First, typed element accessors for scalar values
- //////////////////////////////////////////////////////////
- */
-
- /**
- *
- *
- *
Read an element content as a 32-bit integer. The lexical - * representation of a integer is defined by the - * XML Schema integer data type. Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the XML Schema integer data type. - * An exception is thrown if, after whitespace is - * collapsed, the resulting sequence of characters is not in - * the lexical space defined by the XML Schema integer data type. - *
- * These are the pre and post conditions of calling this method: - *
Read an element content as a 64-bit integer. The lexical - * representation of a integer is defined by the - * XML Schema integer data type. Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the XML Schema integer data type. - * An exception is thrown if, after whitespace is - * collapsed, the resulting sequence of characters is not in - * the lexical space defined by the XML Schema integer data type. - *
- * These are the pre and post conditions of calling this method: - *
Read an element content as a 32-bit floating point value.
- * The lexical representation is defined by the
- * XML Schema float data type. Whitespace MUST be
- * collapsed
- * according to the whiteSpace facet for the XML Schema float data type.
- * An exception is thrown if, after whitespace is
- * collapsed, the resulting sequence of characters is not in
- * the lexical space defined by the XML Schema integer data type.
- *
- * Note that valid representations include basic Java textual
- * representations, as well as 3 special tokens: "INF", "-INF"
- * and "NaN"
- *
- * These are the pre and post conditions of calling this method: - *
Read an element content as a 64-bit floating point value.
- * The lexical representation is defined by the
- * XML Schema double data type. Whitespace MUST be
- * collapsed
- * according to the whiteSpace facet for the XML Schema double data type.
- * An exception is thrown if, after whitespace is
- * collapsed, the resulting sequence of characters is not in
- * the lexical space defined by the XML Schema integer data type.
- *
- * Note that valid representations include basic Java textual
- * representations, as well as 3 special tokens: "INF", "-INF"
- * and "NaN"
- *
- * These are the pre and post conditions of calling this method: - *
- * Note: base64 variant defaults to {@link Base64Variants#MIME}. - * - * @see #readElementAsBinary - */ - public byte[] getElementAsBinary() - throws XMLStreamException; - - /** - * Convenience method that can be used similar to read binary content - * instead of - * {@link #readElementAsBinary}, in cases where neither performance nor - * memory usage is a big concern. - * - * @param variant Base64 variant content is in; needed to decode - * alternative variants ("modified base64") - * - * @see #readElementAsBinary - */ - public byte[] getElementAsBinary(Base64Variant variant) - throws XMLStreamException; - - /** - * Generic decoding method that can be used for efficient - * decoding of additional types not support natively - * by the typed stream reader. When method is called, - * stream reader will collect all textual content of - * the current element (effectively doing something - * similar to a call to {@link #getElementText}, - * and then call one of decode methods defined in - * {@link TypedValueDecoder}. The only difference is that - * passed value will be trimmed: that is, any leading or - * trailing white space will be removed prior to calling - * decode method. - * After the call, passed - * decoder object will have decoded and stored value - * (if succesful) or thrown an exception (if not). - *
- * The main benefit of using this method (over just getting - * all content by calling {@link #getElementText} - * is efficiency: the stream reader can efficiently gather all textual - * content necessary and pass it to the decoder, often avoiding - * construction of intemediate Strings. - *
- * These are the pre- and post-conditions of calling this method: - *
- * Note that caller has to know more specific type of decoder, - * since the base interface does not specify methods - * for accessing actual decoded value. - */ - public void getElementAs(TypedValueDecoder tvd) throws XMLStreamException; - - /* - ////////////////////////////////////////////////////////// - // Then streaming/chunked typed element accessors - // for non-scalar (array, binary data) values - ////////////////////////////////////////////////////////// - */ - - /** - * Read element content as decoded byte sequence; possibly only - * reading a fragment of all element content. - * The lexical representation of a byte array is defined by the - * XML Schema base64Binary data type. Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the XML Schema base64Binary - * data type. An exception is thrown if content is not in - * the lexical space defined by the XML Schema base64Binary data type. - *
- * Each call will read at least one decoded byte (and no more than - * the specified maximum length), if there is any content remaining. - * If none is available and END_ELEMENT is encountered, -1 is - * returned. - *
- * These are the pre and post conditions of calling this method: - *
- * Additionally, caller MUST start decoding at START_ELEMENT; - * if the first decode calls is at CHARACTERS or CDATA event, results - * are not defined: result may be an exception, or invalid data being - * returned. Implementations are encouraged to throw an exception - * if possible, to make it easier to figure out the problem. - *
- * This method can be called multiple times until the cursor - * is positioned at the corresponding END_ELEMENT event. Stated - * differently, after the method is called for the first time, - * the cursor will move and remain in the CHARACTERS position while there - * are potentially more bytes available for reading. - *
- * - * @param resultBuffer Array in which to copy decoded bytes. - * @param offset Starting offset of the first decoded byte - * within result buffer - * @param maxLength Maximun number of bytes to decode with this call - * - * @return The number of bytes actually decoded and returned, - * if any were available; -1 if there is no more content. - * If any content was copied, value must be less or equal than - *maxLength
- * Note that this value is not guaranteed to equal maxLength
- * even if enough content was available; that is, implementations
- * can return shorter sections if they choose to, down to and including
- * returning zero (0) if it was not possible to decode a full base64
- * triplet (3 output bytes from 4 input characters).
- *
- * @throws IllegalArgumentException If resultBuffer
is
- * null or offset is less than 0.
- */
- public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength,
- Base64Variant variant)
- throws XMLStreamException;
-
- public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength)
- throws XMLStreamException;
-
- /**
- * Read an element content as an int array. The lexical
- * representation of a int array is defined by the following
- * XML schema type:
- * - * <xs:simpleType name="intArray"> - * <xs:list itemType="xs:int"/> - * </xs:simpleType>- * whose lexical space is a list of space-separated ints. - * Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the
intArray
- * type shown above. An exception is thrown if, after whitespace is
- * collapsed, the resulting sequence of characters is not in
- * the lexical space defined by the intArray
data
- * type.
- *
- *- *These are the pre and post conditions of calling this - * method: - *
length
, but
- * at least one if any ints found. If not, -1 is returned
- * to signal end of ints to parse.
- *
- * @throws IllegalStateException If called on event other than
- * START_ELEMENT, END_ELEMENT, or CHARACTERS (which resulted from
- * an earlier call)
- */
- public int readElementAsIntArray(int[] resultBuffer, int offset, int length) throws XMLStreamException;
-
- public int readElementAsLongArray(long[] resultBuffer, int offset, int length) throws XMLStreamException;
-
- public int readElementAsFloatArray(float[] resultBuffer, int offset, int length) throws XMLStreamException;
-
- public int readElementAsDoubleArray(double[] resultBuffer, int offset, int length) throws XMLStreamException;
-
- /**
- * Read an element content as an array of tokens. This is done by
- * reader tokenizing textual content by white space, and sending
- * each token to specified decoder for decoding. This is repeated
- * as long as element content has more tokens and decoder can
- * accept more values.
- *- *These are the pre- and post-conditions of calling this - * method: - *
- * Note: passed decoder must accept at least one value, reader will
- * not verify capacity before calling it with the first token.
- *
- * @return Number of elements decoded, or -1 to indicate that there
- * was no more element content tokens to decode.
- *
- * @throws IllegalStateException If called on event other than
- * START_ELEMENT, END_ELEMENT, or CHARACTERS (which resulted from
- * an earlier call)
- */
- public int readElementAsArray(TypedArrayDecoder tad) throws XMLStreamException;
-
- /*
- //////////////////////////////////////////////////////////
- // Then, typed attribute accessors
- //////////////////////////////////////////////////////////
- */
-
- /**
- * Returns the index of the attribute whose local name is
- * localName
and URI is namespaceURI
- * or -1
if no such attribute exists.
- *
- * @param namespaceURI The attribute's namespace URI. Values of
- * null and "" are considered the same, i.e. "no namespace"
- * (or "empty" namespace)
- * @param localName The attribute's local name.
- * @return The attribute's index or -1
if no
- * such attribute exists.
- * @throws java.lang.IllegalStateException If this is not
- * a START_ELEMENT event
- * @throws XMLStreamException If unable to convert the resulting
- * character sequence into an XML Schema boolean value.
- */
- public int getAttributeIndex(String namespaceURI, String localName);
-
- /**
- *
Read an attribute value as a boolean. The lexical - * representation of a boolean is defined by the - * XML Schema boolean - * data type. Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the XML Schema boolean - * data type. - * An exception is thrown if, after whitespace is - * collapsed, the resulting sequence of characters is not in - * the lexical space defined by the XML Schema boolean data type.
- * - * @param index The attribute's index as returned by {@link #getAttributeIndex(String, String)} - * @throws java.lang.IllegalStateException If this is not - * a START_ELEMENT event. - * @throws XMLStreamException If unable to convert the resulting - * character sequence into an XML Schema boolean value. - */ - public boolean getAttributeAsBoolean(int index) throws XMLStreamException; - - /** - *Read an attribute value as a boolean. The lexical - * representation of a boolean is defined by the - * XML Schema integer - * data type. Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the type. - * An exception is thrown if, after whitespace is - * collapsed, the resulting sequence of characters is not in - * the lexical space defined by the XML Schema integer data type.
- * - * @param index The attribute's index as returned by {@link #getAttributeIndex(String, String)} - * @throws java.lang.IllegalStateException If this is not a START_ELEMENT event. - * @throws XMLStreamException If unable to convert the resulting - * character sequence into an XML Schema boolean value. - */ - public int getAttributeAsInt(int index) throws XMLStreamException; - - /** - *Read an attribute value as a boolean. The lexical - * representation of a boolean is defined by the - * XML Schema long - * data type. Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the type. - * An exception is thrown if, after whitespace is - * collapsed, the resulting sequence of characters is not in - * the lexical space defined by the XML Schema long data type. - *
- * @param index The attribute's index as returned by {@link #getAttributeIndex(String, String)} - * @throws java.lang.IllegalStateException If this is not a START_ELEMENT event. - * @throws XMLStreamException If unable to convert the resulting - * character sequence into an XML Schema boolean value. - */ - public long getAttributeAsLong(int index) throws XMLStreamException; - - public float getAttributeAsFloat(int index) throws XMLStreamException; - - public double getAttributeAsDouble(int index) throws XMLStreamException; - - public BigInteger getAttributeAsInteger(int index) throws XMLStreamException; - - public BigDecimal getAttributeAsDecimal(int index) throws XMLStreamException; - - public QName getAttributeAsQName(int index) throws XMLStreamException; - - // !!! 30-Jan-2008, TSa: JDK 1.5 only -- is that ok? - //XMLGregorianCalendar getAttributeAsCalendar(int index) throws XMLStreamException; - - /** - * Generic access method that can be used for efficient - * decoding of additional types not support natively - * by the typed stream reader. The main benefit of using - * this method is that the stream reader can efficient - * gather all textual content necessary and pass it - * to the decoder, often avoiding construction of intemediate - * Strings. - *- * As with {@link #getElementAs}, value passed to a decode - * method will be trimmed of any leading or trailing white space. - */ - public void getAttributeAs(int index, TypedValueDecoder tvd) throws XMLStreamException; - - /** - *Read an attribute value as a byte array. The lexical - * representation of a byte array is defined by the - * XML Schema base64Binary data type. Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the XML Schema base64Binary - * data type. An exception is thrown if, after whitespace is - * collapsed, the resulting sequence of characters is not in - * the lexical space defined by the XML Schema base64Binary data type.
- * - * @param index The attribute's index as returned by {@link - * #getAttributeIndex(String, String)}. - * @return An array of bytes with the content. - * @throws java.lang.IllegalStateException If this is not - * a START_ELEMENT or ATTRIBUTE event. - * @throws XMLStreamException If unable to convert the resulting - * character sequence into an XML Schema boolean value. - */ - public byte[] getAttributeAsBinary(int index) throws XMLStreamException; - - public byte[] getAttributeAsBinary(int index, Base64Variant v) throws XMLStreamException; - - /** - *Read an attribute content as an int array. The lexical - * representation of a int array is defined by the following - * XML schema type: - *
- * <xs:simpleType name="intArray"> - * <xs:list itemType="xs:int"/> - * </xs:simpleType>- * whose lexical space is a list of space-separated ints. - * Whitespace MUST be - * collapsed - * according to the whiteSpace facet for the
intArray
- * type shown above. An exception is thrown if, after whitespace is
- * collapsed, the resulting sequence of characters is not in
- * the lexical space defined by the intArray
data
- * type.
- *
- * @param index The attribute's index as returned by {@link
- * #getAttributeIndex(String, String)}.
- * @return An array of ints with the content.
- * @throws java.lang.IllegalStateException If this is not
- * a START_ELEMENT or ATTRIBUTE event.
- * @throws XMLStreamException If unable to convert the resulting
- * character sequence into an XML Schema boolean value.
- */
- public int[] getAttributeAsIntArray(int index) throws XMLStreamException;
-
- public long[] getAttributeAsLongArray(int index) throws XMLStreamException;
-
- public float[] getAttributeAsFloatArray(int index) throws XMLStreamException;
-
- public double[] getAttributeAsDoubleArray(int index) throws XMLStreamException;
-
- /**
- * Method that allows reading contents of an attribute as an array
- * of whitespace-separate tokens, decoded using specified decoder.
- *
- * @return Number of tokens decoded, 0 if none found
- */
- public int getAttributeAsArray(int index, TypedArrayDecoder tad) throws XMLStreamException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamWriter.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamWriter.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamWriter.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/typed/TypedXMLStreamWriter.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,238 +0,0 @@
-package org.codehaus.stax2.typed;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-// !!! 30-Jan-2008, TSa: JDK 1.5 only, can't add yet
-//import javax.xml.datatype.XMLGregorianCalendar;
-
-import javax.xml.namespace.QName;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
-
-/**
- * This interface provides a typed extension to
- * {@link javax.xml.stream.XMLStreamWriter}. It defines methods for
- * writing XML data from Java types.
- *- * Exceptions to throw are declared to be basic {@link XMLStreamException}s, - * because in addition to specific {@link TypedXMLStreamException}s - * (which are more specific subclasses) - * that are thrown if conversion itself fails, methods also need to - * access underlying textual content which may throw other subtypes - * of stream exception. - * - * @author Santiago.PericasGeertsen@sun.com - * @author Tatu Saloranta - * - * @since 3.0 - */ -public interface TypedXMLStreamWriter - extends XMLStreamWriter -{ - /* - ////////////////////////////////////////////////////////// - // First, typed element write methods for scalar values - ////////////////////////////////////////////////////////// - */ - - /** - * Write a boolean value to the output as textual element content. - * The lexical representation of content is defined by the - * XML Schema boolean data type. - * - * @param value The boolean value to write. - */ - void writeBoolean(boolean value) throws XMLStreamException; - - /** - * Write an int value to the output as textual element content. - * The lexical representation of content is defined by the - * XML Schema integer data type. - */ - void writeInt(int value) throws XMLStreamException; - - /** - * Write a long value to the output as textual element content. - * The lexical representation of content is defined by the - * XML Schema long data type. - */ - void writeLong(long value) throws XMLStreamException; - - /** - * Write a float value to the output as textual element content. - * The lexical representation of content is defined by the - * XML Schema float data type. - */ - void writeFloat(float value) throws XMLStreamException; - - /** - * Write a double value to the output as textual element content. - * The lexical representation of content is defined by the - * XML Schema double data type. - */ - void writeDouble(double value) throws XMLStreamException; - - void writeInteger(BigInteger value) throws XMLStreamException; - - /** - * Write a decimal value to the output as textual element content. - * The lexical representation of content is defined by the - * XML Schema decimal data type. - */ - void writeDecimal(BigDecimal value) throws XMLStreamException; - - void writeQName(QName value) throws XMLStreamException; - - // !!! 30-Jan-2008, TSa: JDK 1.5 only, can't add yet - //void writeCalendar(XMLGregorianCalendar value) throws XMLStreamException; - - /* - ////////////////////////////////////////////////////////// - // Then streaming/chunked typed element write methods - // for non-scalar (array, binary data) values - ////////////////////////////////////////////////////////// - */ - - /** - *
- * Write binary content as base64 encoded characters to the output. - * The lexical representation of a byte array is defined by the - * XML Schema base64Binary data type. This method can be called - * multiple times to write the array in chunks; but if so, - * callers should write output in chunks divisible by 3 (natural - * atomic unit of base64 output, which avoids padding) to - * maximize interoperability. - *
- *- * Note: base64 variant defaults to {@link Base64Variants#MIME}. - * - * @param value The array from which to write the bytes. - * @param from The index in the array from which writing starts. - * @param length The number of bytes to write. - */ - void writeBinary(byte[] value, int from, int length) throws XMLStreamException; - - void writeBinary(Base64Variant variant, byte[] value, int from, int length) throws XMLStreamException; - - /** - *
Write int array to the output. The lexical - * representation of a int array is defined by the following - * XML schema type: - *
- * <xs:simpleType name="intArray"> - * <xs:list itemType="xs:int"/> - * </xs:simpleType>- * whose lexical space is a list of space-separated ints. - * This method can be called multiple times to write the - * array in chunks. - * - * @param value The array from which to write the ints. - * @param from The index in the array from which writing starts. - * @param length The number of ints to write. - */ - void writeIntArray(int[] value, int from, int length) throws XMLStreamException; - - void writeLongArray(long[] value, int from, int length) throws XMLStreamException; - - void writeFloatArray(float[] value, int from, int length) throws XMLStreamException; - - void writeDoubleArray(double[] value, int from, int length) throws XMLStreamException; - - - // -- Attributes -- - - /** - * Write a boolean value to the output as attribute value. - * The lexical representation of content is defined by the - * XML Schema boolean data type. - * - * @param prefix The attribute's prefix. Null or "" if no prefix is to be used - * @param namespaceURI The attribute's URI (can be either null or empty String for "no namespace") - * @param localName The attribute's local name - * @param value The boolean value to write. - */ - void writeBooleanAttribute(String prefix, String namespaceURI, String localName, boolean value) throws XMLStreamException; - - /** - * Write an integer value to the output as attribute value. - * The lexical representation of content is defined by the - * XML Schema integer data type. - * - * @param prefix The attribute's prefix. Null or "" if no prefix is to be used - * @param namespaceURI The attribute's URI (can be either null or empty String for "no namespace") - * @param localName The attribute's local name - * @param value The integer value to write. - */ - void writeIntAttribute(String prefix, String namespaceURI, String localName, int value) throws XMLStreamException; - - /** - * Write an long value to the output as attribute value. - * The lexical representation of content is defined by the - * XML Schema long data type. - * - * @param prefix The attribute's prefix. Null or "" if no prefix is to be used - * @param namespaceURI The attribute's URI (can be either null or empty String for "no namespace") - * @param localName The attribute's local name - * @param value The long value to write. - */ - void writeLongAttribute(String prefix, String namespaceURI, String localName, long value) throws XMLStreamException; - - void writeFloatAttribute(String prefix, String namespaceURI, String localName, float value) - throws XMLStreamException; - - void writeDoubleAttribute(String prefix, String namespaceURI, String localName, double value) - throws XMLStreamException; - - void writeIntegerAttribute(String prefix, String namespaceURI, String localName, BigInteger value) throws XMLStreamException; - - void writeDecimalAttribute(String prefix, String namespaceURI, String localName, BigDecimal value) throws XMLStreamException; - - void writeQNameAttribute(String prefix, String namespaceURI, String localName, QName value) throws XMLStreamException; - - // !!! 30-Jan-2008, TSa: JDK 1.5 only -- is that ok? - //void writeCalendarAttribute(String prefix, String namespaceURI, String localName, XMLGregorianCalendar value) throws XMLStreamException; - - /* 25-Apr-2008, tatus: Do we even want to deal with structured - * or binary typed access with attributes? - */ - - /** - *
Write a byte array attribute. The lexical - * representation of a byte array is defined by the - * XML Schema base64Binary data type.
- *- * Note: base64 variant defaults to {@link Base64Variants#MIME}. - * - * @param prefix The attribute's prefix. - * @param namespaceURI The attribute's URI. - * @param localName The attribute's local name. - * @param value The array from which to write the bytes. - */ - void writeBinaryAttribute(String prefix, String namespaceURI, String localName, byte[] value) throws XMLStreamException; - - void writeBinaryAttribute(Base64Variant variant, String prefix, String namespaceURI, String localName, byte[] value) throws XMLStreamException; - - /** - *
Write int array attribute. The lexical - * representation of a int array is defined by the following - * XML schema type: - *
- * <xs:simpleType name="intArray"> - * <xs:list itemType="xs:int"/> - * </xs:simpleType>- * whose lexical space is a list of space-separated ints. - * - * @param prefix The attribute's prefix. - * @param namespaceURI The attribute's URI. - * @param localName The attribute's local name. - * @param value The array from which to write the ints. - */ - void writeIntArrayAttribute(String prefix, String namespaceURI, String localName, int[] value) throws XMLStreamException; - - void writeLongArrayAttribute(String prefix, String namespaceURI, String localName, long[] value) throws XMLStreamException; - - void writeFloatArrayAttribute(String prefix, String namespaceURI, String localName, float[] value) throws XMLStreamException; - - void writeDoubleArrayAttribute(String prefix, String namespaceURI, String localName, double[] value) throws XMLStreamException; -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/util/StreamReader2Delegate.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/util/StreamReader2Delegate.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/util/StreamReader2Delegate.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/util/StreamReader2Delegate.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,314 +0,0 @@ -package org.codehaus.stax2.util; - -import java.io.IOException; -import java.io.Writer; -import java.math.BigDecimal; -import java.math.BigInteger; - -import javax.xml.namespace.NamespaceContext; -import javax.xml.namespace.QName; -import javax.xml.stream.XMLStreamException; -import javax.xml.stream.XMLStreamReader; -import javax.xml.stream.util.StreamReaderDelegate; - -import org.codehaus.stax2.AttributeInfo; -import org.codehaus.stax2.DTDInfo; -import org.codehaus.stax2.LocationInfo; -import org.codehaus.stax2.XMLStreamReader2; -import org.codehaus.stax2.typed.Base64Variant; -import org.codehaus.stax2.typed.TypedArrayDecoder; -import org.codehaus.stax2.typed.TypedValueDecoder; -import org.codehaus.stax2.validation.ValidationProblemHandler; -import org.codehaus.stax2.validation.XMLValidationSchema; -import org.codehaus.stax2.validation.XMLValidator; - -public class StreamReader2Delegate - extends StreamReaderDelegate - implements XMLStreamReader2 -{ - protected XMLStreamReader2 mDelegate2; - - /* - ////////////////////////////////////////////// - // Life-cycle - ////////////////////////////////////////////// - */ - - public StreamReader2Delegate(XMLStreamReader2 sr) - { - super(sr); - mDelegate2 = sr; - } - - // @Override - public void setParent(XMLStreamReader pr) - { - super.setParent(pr); - mDelegate2 = (XMLStreamReader2) pr; - } - - /* - ////////////////////////////////////////////// - // XMLStreamReader2 implementation - ////////////////////////////////////////////// - */ - - public void closeCompletely() throws XMLStreamException { - mDelegate2.closeCompletely(); - } - - public AttributeInfo getAttributeInfo() throws XMLStreamException { - return mDelegate2.getAttributeInfo(); - } - - public DTDInfo getDTDInfo() throws XMLStreamException { - return mDelegate2.getDTDInfo(); - } - - public int getDepth() { - return mDelegate2.getDepth(); - } - - public Object getFeature(String name) { - return mDelegate2.getFeature(name); - } - - public LocationInfo getLocationInfo() { - return mDelegate2.getLocationInfo(); - } - - public NamespaceContext getNonTransientNamespaceContext() { - return mDelegate2.getNonTransientNamespaceContext(); - } - - public String getPrefixedName() { - return mDelegate2.getPrefixedName(); - } - - public int getText(Writer w, boolean preserveContents) - throws IOException, XMLStreamException - { - return mDelegate2.getText(w, preserveContents); - } - - public boolean isEmptyElement() - throws XMLStreamException - { - return mDelegate2.isEmptyElement(); - } - - public boolean isPropertySupported(String name) { - return mDelegate2.isPropertySupported(name); - } - - public void setFeature(String name, Object value) { - mDelegate2.setFeature(name, value); - } - - public boolean setProperty(String name, Object value) { - return mDelegate2.setProperty(name, value); - } - - public void skipElement() throws XMLStreamException { - mDelegate2.skipElement(); - } - - /* - ////////////////////////////////////////////// - // XMLStreamReader2, Validatable - ////////////////////////////////////////////// - */ - - public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h) { - return mDelegate2.setValidationProblemHandler(h); - } - - public XMLValidator stopValidatingAgainst(XMLValidationSchema schema) - throws XMLStreamException - { - return mDelegate2.stopValidatingAgainst(schema); - } - - public XMLValidator stopValidatingAgainst(XMLValidator validator) - throws XMLStreamException - { - return mDelegate2.stopValidatingAgainst(validator); - } - - public XMLValidator validateAgainst(XMLValidationSchema schema) - throws XMLStreamException - { - return mDelegate2.validateAgainst(schema); - } - - /* - ////////////////////////////////////////////// - // TypedXMLStreamReader implementation - ////////////////////////////////////////////// - */ - - public int getAttributeIndex(String namespaceURI, String localName) { - return mDelegate2.getAttributeIndex(namespaceURI, localName); - } - - public boolean getAttributeAsBoolean(int index) throws XMLStreamException - { - return mDelegate2.getAttributeAsBoolean(index); - } - - public BigDecimal getAttributeAsDecimal(int index) - throws XMLStreamException - { - return mDelegate2.getAttributeAsDecimal(index); - } - - public double getAttributeAsDouble(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsDouble(index); - } - - public float getAttributeAsFloat(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsFloat(index); - } - - public int getAttributeAsInt(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsInt(index); - } - - public BigInteger getAttributeAsInteger(int index) - throws XMLStreamException - { - return mDelegate2.getAttributeAsInteger(index); - } - - public long getAttributeAsLong(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsLong(index); - } - - public QName getAttributeAsQName(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsQName(index); - } - - public int[] getAttributeAsIntArray(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsIntArray(index); - } - - public long[] getAttributeAsLongArray(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsLongArray(index); - } - - public float[] getAttributeAsFloatArray(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsFloatArray(index); - } - - public double[] getAttributeAsDoubleArray(int index) throws XMLStreamException { - return mDelegate2.getAttributeAsDoubleArray(index); - } - - public void getElementAs(TypedValueDecoder tvd) throws XMLStreamException { - mDelegate2.getElementAs(tvd); - } - - public boolean getElementAsBoolean() throws XMLStreamException { - return mDelegate2.getElementAsBoolean(); - } - - public BigDecimal getElementAsDecimal() throws XMLStreamException { - return mDelegate2.getElementAsDecimal(); - } - - public double getElementAsDouble() throws XMLStreamException { - return mDelegate2.getElementAsDouble(); - } - - public float getElementAsFloat() throws XMLStreamException { - return mDelegate2.getElementAsFloat(); - } - - public int getElementAsInt() throws XMLStreamException { - return mDelegate2.getElementAsInt(); - } - - public BigInteger getElementAsInteger() throws XMLStreamException { - return mDelegate2.getElementAsInteger(); - } - - public long getElementAsLong() throws XMLStreamException { - return mDelegate2.getElementAsLong(); - } - - public QName getElementAsQName() throws XMLStreamException { - return mDelegate2.getElementAsQName(); - } - - public byte[] getElementAsBinary() throws XMLStreamException { - return mDelegate2.getElementAsBinary(); - } - - public byte[] getElementAsBinary(Base64Variant v) throws XMLStreamException { - return mDelegate2.getElementAsBinary(v); - } - - public void getAttributeAs(int index, TypedValueDecoder tvd) - throws XMLStreamException - { - mDelegate2.getAttributeAs(index, tvd); - } - - public int getAttributeAsArray(int index, TypedArrayDecoder tad) - throws XMLStreamException - { - return mDelegate2.getAttributeAsArray(index, tad); - } - - public byte[] getAttributeAsBinary(int index) throws XMLStreamException - { - return mDelegate2.getAttributeAsBinary(index); - } - - public byte[] getAttributeAsBinary(int index, Base64Variant v) throws XMLStreamException - { - return mDelegate2.getAttributeAsBinary(index, v); - } - - public int readElementAsDoubleArray(double[] value, int from, int length) - throws XMLStreamException - { - return mDelegate2.readElementAsDoubleArray(value, from, length); - } - - public int readElementAsFloatArray(float[] value, int from, int length) - throws XMLStreamException - { - return mDelegate2.readElementAsFloatArray(value, from, length); - } - - public int readElementAsIntArray(int[] value, int from, int length) - throws XMLStreamException { - return mDelegate2.readElementAsIntArray(value, from, length); - } - - public int readElementAsLongArray(long[] value, int from, int length) - throws XMLStreamException - { - return mDelegate2.readElementAsLongArray(value, from, length); - } - - public int readElementAsArray(TypedArrayDecoder tad) - throws XMLStreamException - { - return mDelegate2.readElementAsArray(tad); - } - - public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength) - throws XMLStreamException - { - return mDelegate2.readElementAsBinary(resultBuffer, offset, maxLength); - } - - public int readElementAsBinary(byte[] resultBuffer, int offset, int maxLength, - Base64Variant v) - throws XMLStreamException - { - return mDelegate2.readElementAsBinary(resultBuffer, offset, maxLength, v); - } -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/util/StreamWriter2Delegate.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/util/StreamWriter2Delegate.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/util/StreamWriter2Delegate.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/util/StreamWriter2Delegate.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,275 +0,0 @@ -package org.codehaus.stax2.util; - -import java.math.BigDecimal; -import java.math.BigInteger; - -import javax.xml.namespace.QName; -import javax.xml.stream.XMLStreamException; -import javax.xml.stream.XMLStreamWriter; - -import org.codehaus.stax2.XMLStreamLocation2; -import org.codehaus.stax2.XMLStreamReader2; -import org.codehaus.stax2.XMLStreamWriter2; -import org.codehaus.stax2.typed.Base64Variant; -import org.codehaus.stax2.validation.ValidationProblemHandler; -import org.codehaus.stax2.validation.XMLValidationSchema; -import org.codehaus.stax2.validation.XMLValidator; - -public class StreamWriter2Delegate - extends StreamWriterDelegate - implements XMLStreamWriter2 -{ - protected XMLStreamWriter2 mDelegate2; - - /* - ////////////////////////////////////////////// - // Life-cycle - ////////////////////////////////////////////// - */ - - public StreamWriter2Delegate(XMLStreamWriter2 parent) - { - super(parent); - } - // @Override - public void setParent(XMLStreamWriter w) - { - super.setParent(w); - mDelegate2 = (XMLStreamWriter2) w; - } - - /* - ////////////////////////////////////////////// - // XMLStreamWriter2 implementation - ////////////////////////////////////////////// - */ - - public void closeCompletely() throws XMLStreamException - { - mDelegate2.closeCompletely(); - } - - public void copyEventFromReader(XMLStreamReader2 r, boolean preserveEventData) - throws XMLStreamException - { - mDelegate2.copyEventFromReader(r, preserveEventData); - } - - public String getEncoding() { - return mDelegate2.getEncoding(); - } - - public XMLStreamLocation2 getLocation() { - return mDelegate2.getLocation(); - } - - public boolean isPropertySupported(String name) { - return mDelegate2.isPropertySupported(name); - } - - public boolean setProperty(String name, Object value) { - return mDelegate2.setProperty(name, value); - } - - public void writeCData(char[] text, int start, int len) - throws XMLStreamException { - mDelegate2.writeCData(text, start, len); - } - - public void writeDTD(String rootName, String systemId, String publicId, - String internalSubset) throws XMLStreamException { - mDelegate2.writeDTD(rootName, systemId, publicId, internalSubset); - } - - public void writeFullEndElement() throws XMLStreamException { - mDelegate2.writeFullEndElement(); - } - - public void writeRaw(String text) throws XMLStreamException { - mDelegate2.writeRaw(text); - } - - public void writeRaw(String text, int offset, int length) - throws XMLStreamException - { - mDelegate2.writeRaw(text, offset, length); - } - - public void writeRaw(char[] text, int offset, int length) - throws XMLStreamException { - mDelegate2.writeRaw(text, offset, length); - } - - public void writeSpace(String text) throws XMLStreamException { - mDelegate2.writeSpace( text); - } - - public void writeSpace(char[] text, int offset, int length) - throws XMLStreamException - { - mDelegate2.writeSpace(text, offset, length); - } - - public void writeStartDocument(String version, String encoding, - boolean standAlone) throws XMLStreamException { - mDelegate2.writeStartDocument(version, encoding, standAlone); - } - - public void writeBinary(byte[] value, int from, int length) - throws XMLStreamException - { - mDelegate2.writeBinary(value, from, length); - } - - public void writeBinary(Base64Variant v, byte[] value, int from, int length) - throws XMLStreamException - { - mDelegate2.writeBinary(v, value, from, length); - } - - public void writeBinaryAttribute(String prefix, String namespaceURI, - String localName, byte[] value) throws XMLStreamException { - mDelegate2.writeBinaryAttribute(prefix, namespaceURI, localName, value); - } - - public void writeBinaryAttribute(Base64Variant v, String prefix, String namespaceURI, - String localName, byte[] value) throws XMLStreamException { - mDelegate2.writeBinaryAttribute(v, prefix, namespaceURI, localName, value); - } - - public void writeBoolean(boolean value) throws XMLStreamException { - mDelegate2.writeBoolean(value); - } - - public void writeBooleanAttribute(String prefix, String namespaceURI, - String localName, boolean value) throws XMLStreamException { - mDelegate2.writeBooleanAttribute(prefix, namespaceURI, localName, value); - } - - public void writeDecimal(BigDecimal value) throws XMLStreamException { - mDelegate2.writeDecimal(value); - } - - public void writeDecimalAttribute(String prefix, String namespaceURI, - String localName, BigDecimal value) throws XMLStreamException { - mDelegate2.writeDecimalAttribute(prefix, namespaceURI, localName, value); - } - - public void writeDouble(double value) throws XMLStreamException { - mDelegate2.writeDouble(value); - } - - public void writeDoubleArray(double[] value, int from, int length) - throws XMLStreamException { - mDelegate2.writeDoubleArray(value, from, length); - } - - public void writeDoubleArrayAttribute(String prefix, String namespaceURI, - String localName, double[] value) throws XMLStreamException { - mDelegate2.writeDoubleArrayAttribute(prefix, namespaceURI, localName, value); - } - - public void writeDoubleAttribute(String prefix, String namespaceURI, - String localName, double value) throws XMLStreamException { - mDelegate2.writeDoubleAttribute(prefix, namespaceURI, localName, value); - } - - public void writeFloat(float value) throws XMLStreamException { - mDelegate2.writeFloat(value); - } - - public void writeFloatArray(float[] value, int from, int length) - throws XMLStreamException - { - mDelegate2.writeFloatArray(value, from, length); - } - - public void writeFloatArrayAttribute(String prefix, String namespaceURI, - String localName, float[] value) throws XMLStreamException { - mDelegate2.writeFloatArrayAttribute(prefix, namespaceURI, localName, value); - } - - public void writeFloatAttribute(String prefix, String namespaceURI, - String localName, float value) throws XMLStreamException { - mDelegate2.writeFloatAttribute( prefix, namespaceURI, localName, value); - } - - public void writeInt(int value) throws XMLStreamException { - mDelegate2.writeInt(value); - } - - public void writeIntArray(int[] value, int from, int length) - throws XMLStreamException { - mDelegate2.writeIntArray(value, from, length); - } - - public void writeIntArrayAttribute(String prefix, String namespaceURI, - String localName, int[] value) throws XMLStreamException { - mDelegate2.writeIntArrayAttribute( prefix, namespaceURI, localName, value); - } - - public void writeIntAttribute(String prefix, String namespaceURI, - String localName, int value) throws XMLStreamException { - mDelegate2.writeIntAttribute( prefix, namespaceURI, localName, value); - } - - public void writeInteger(BigInteger value) throws XMLStreamException { - mDelegate2.writeInteger(value); - } - - public void writeIntegerAttribute(String prefix, String namespaceURI, - String localName, BigInteger value) throws XMLStreamException { - mDelegate2.writeIntegerAttribute( prefix, namespaceURI, localName, value); - } - - public void writeLong(long value) throws XMLStreamException { - mDelegate2.writeLong(value); - } - - public void writeLongArray(long[] value, int from, int length) - throws XMLStreamException { - mDelegate2.writeLongArray(value, from, length); - } - - public void writeLongArrayAttribute(String prefix, String namespaceURI, - String localName, long[] value) throws XMLStreamException { - mDelegate2.writeLongArrayAttribute( prefix, namespaceURI, localName, value); - } - - public void writeLongAttribute(String prefix, String namespaceURI, - String localName, long value) throws XMLStreamException { - mDelegate2.writeLongAttribute(prefix, namespaceURI, localName, value); - } - - public void writeQName(QName value) throws XMLStreamException { - mDelegate2.writeQName(value); - } - - public void writeQNameAttribute(String prefix, String namespaceURI, String localName, QName value) - throws XMLStreamException - { - mDelegate2.writeQNameAttribute(prefix, namespaceURI, localName, value); - } - - public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h) { - return mDelegate2.setValidationProblemHandler(h); - } - - public XMLValidator stopValidatingAgainst(XMLValidationSchema schema) - throws XMLStreamException - { - return mDelegate2.stopValidatingAgainst(schema); - } - - public XMLValidator stopValidatingAgainst(XMLValidator validator) - throws XMLStreamException - { - return mDelegate2.stopValidatingAgainst(validator); - } - - public XMLValidator validateAgainst(XMLValidationSchema schema) - throws XMLStreamException - { - return mDelegate2.validateAgainst(schema); - } -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/util/StreamWriterDelegate.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/util/StreamWriterDelegate.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/util/StreamWriterDelegate.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/util/StreamWriterDelegate.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,228 +0,0 @@ -/* StAX2 extension for StAX API (JSR-173). - * - * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi - * - * Licensed under the License specified in file LICENSE, included with - * the source code. - * You may not use this file except in compliance with the License. - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.codehaus.stax2.util; - -import javax.xml.namespace.NamespaceContext; -import javax.xml.stream.XMLStreamException; -import javax.xml.stream.XMLStreamWriter; - -/** - * Similar to {@link javax.xml.stream.util.StreamReaderDelegate}, - * but implements a proxy for {@link XMLStreamWriter}. - * The only additional methods are ones for setting and accessing - * the delegate to forward requests to. - *
- * Note: such class really should exist in core Stax API
- * (in package javax.xml.stream.util
), but since
- * it does not, it is implemented within Stax2 extension API
- *
- * @since 3.0
- */
-public class StreamWriterDelegate
- implements XMLStreamWriter
-{
- protected XMLStreamWriter mDelegate;
-
- /*
- //////////////////////////////////////////////
- // Life-cycle
- //////////////////////////////////////////////
- */
-
- public StreamWriterDelegate(XMLStreamWriter parentWriter)
- {
- mDelegate = parentWriter;
- }
-
- public void setParent(XMLStreamWriter parentWriter)
- {
- mDelegate = parentWriter;
- }
-
- public XMLStreamWriter getParent()
- {
- return mDelegate;
- }
-
- /*
- //////////////////////////////////////////////
- // XMLStreamWriter implementation
- //////////////////////////////////////////////
- */
-
- public void close() throws XMLStreamException {
- mDelegate.close();
- }
-
- public void flush() throws XMLStreamException {
- mDelegate.flush();
-
- }
-
- public NamespaceContext getNamespaceContext() {
- return mDelegate.getNamespaceContext();
- }
-
- public String getPrefix(String ns) throws XMLStreamException {
- return mDelegate.getPrefix(ns);
- }
-
- public Object getProperty(String pname) throws IllegalArgumentException {
- return mDelegate.getProperty(pname);
- }
-
- public void setDefaultNamespace(String ns) throws XMLStreamException {
- mDelegate.setDefaultNamespace(ns);
-
- }
-
- public void setNamespaceContext(NamespaceContext nc)
- throws XMLStreamException
- {
- mDelegate.setNamespaceContext(nc);
-
- }
-
- public void setPrefix(String prefix, String uri) throws XMLStreamException {
- mDelegate.setPrefix(prefix, uri);
-
- }
-
- public void writeAttribute(String arg0, String arg1) throws XMLStreamException {
- mDelegate.writeAttribute(arg0, arg1);
-
- }
-
- public void writeAttribute(String arg0, String arg1, String arg2) throws XMLStreamException {
- mDelegate.writeAttribute(arg0, arg1, arg2);
- }
-
- public void writeAttribute(String arg0, String arg1, String arg2, String arg3) throws XMLStreamException {
- mDelegate.writeAttribute(arg0, arg1, arg2, arg3);
- }
-
- public void writeCData(String arg0) throws XMLStreamException {
- mDelegate.writeCData(arg0);
-
- }
-
- public void writeCharacters(String arg0) throws XMLStreamException {
- mDelegate.writeCharacters(arg0);
-
- }
-
- public void writeCharacters(char[] arg0, int arg1, int arg2)
- throws XMLStreamException {
- mDelegate.writeCharacters(arg0, arg1, arg2);
-
- }
-
- public void writeComment(String arg0) throws XMLStreamException {
- mDelegate.writeComment(arg0);
-
- }
-
- public void writeDTD(String arg0) throws XMLStreamException {
- mDelegate.writeDTD(arg0);
-
- }
-
- public void writeDefaultNamespace(String arg0) throws XMLStreamException {
- mDelegate.writeDefaultNamespace(arg0);
-
- }
-
- public void writeEmptyElement(String arg0) throws XMLStreamException {
- mDelegate.writeEmptyElement(arg0);
-
- }
-
- public void writeEmptyElement(String arg0, String arg1) throws XMLStreamException {
- mDelegate.writeEmptyElement(arg0, arg1);
-
- }
-
- public void writeEmptyElement(String arg0, String arg1, String arg2)
- throws XMLStreamException {
- mDelegate.writeEmptyElement(arg0, arg1, arg2);
-
- }
-
- public void writeEndDocument() throws XMLStreamException {
- mDelegate.writeEndDocument();
-
- }
-
- public void writeEndElement() throws XMLStreamException {
- mDelegate.writeEndElement();
-
- }
-
- public void writeEntityRef(String arg0) throws XMLStreamException {
- mDelegate.writeEntityRef(arg0);
-
- }
-
- public void writeNamespace(String arg0, String arg1)
- throws XMLStreamException {
- mDelegate.writeNamespace(arg0, arg1);
-
- }
-
- public void writeProcessingInstruction(String arg0)
- throws XMLStreamException {
- mDelegate.writeProcessingInstruction(arg0);
-
- }
-
- public void writeProcessingInstruction(String arg0, String arg1)
- throws XMLStreamException {
- mDelegate.writeProcessingInstruction(arg0, arg1);
-
- }
-
- public void writeStartDocument() throws XMLStreamException {
- mDelegate.writeStartDocument();
-
- }
-
- public void writeStartDocument(String arg0) throws XMLStreamException {
- mDelegate.writeStartDocument(arg0);
-
- }
-
- public void writeStartDocument(String arg0, String arg1)
- throws XMLStreamException {
- mDelegate.writeStartDocument(arg0, arg1);
-
- }
-
- public void writeStartElement(String arg0) throws XMLStreamException {
- mDelegate.writeStartElement(arg0);
-
- }
-
- public void writeStartElement(String arg0, String arg1)
- throws XMLStreamException {
- mDelegate.writeStartElement(arg0, arg1);
- }
-
- public void writeStartElement(String arg0, String arg1, String arg2)
- throws XMLStreamException {
- mDelegate.writeStartElement(arg0, arg1, arg2);
- }
-}
-
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/AttributeContainer.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/AttributeContainer.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/AttributeContainer.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/AttributeContainer.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,31 +0,0 @@
-package org.codehaus.stax2.validation;
-
-/**
- * Interface that is used to allow validators to do attribute defaulting.
- * That is, to allow specific post-processing for elements, such that after
- * all attribute values that an xml element has have been processed, it
- * is possible to add new attribute/value pairs in cases where attribute
- * only has a default value in DTD or W3C Schema.
- */
-public interface AttributeContainer
-{
- /**
- * @return Number of atributes container contains currently. Can be used
- * to determine the index number for the next attribute to be added.
- */
- public int getAttributeCount();
-
- /**
- * Method that can be used to add a new attribute value for an attribute
- * that was not yet contained by the container, as part of using attribute
- * default value mechanism.
- *
- * Note: caller has to ensure that the addition would not introduce a
- * duplicate; attribute container implementation is not required to do
- * any validation on attribute name (local name, prefix, uri) or value.
- *
- * @return Index of the newly added attribute.
- */
- public int addDefaultAttribute(String localName, String uri, String prefix,
- String value);
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/DTDValidationSchema.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/DTDValidationSchema.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/DTDValidationSchema.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/DTDValidationSchema.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,71 +0,0 @@
-package org.codehaus.stax2.validation;
-
-/**
- * Specialized interface that covers schema features unique to DTDs.
- * Necessary to have basic level of support for entities and notations.
- */
-public interface DTDValidationSchema
- extends XMLValidationSchema
-{
- /*
- //////////////////////////////////////////////////////////
- // Entity support
- //////////////////////////////////////////////////////////
- */
-
- /**
- * @return Number of general (non-parameter) entities (of all types)
- * declared in this DTD
- * schema (in subsets [internal, external] included)
- */
- public int getEntityCount();
-
- /**
- * @return True if a general entity with the specified name was
- * defined in this dtd
- */
- //public boolean isEntityDefined(String name);
-
- /**
- * @return Index of the entity with given name (between 0 and
- * getEntityCount()-1
)
- * if such general entity
- * was defined in this dtd; -1 if not.
- */
- //public int findEntity(String name);
-
- //public String getEntityName(int index);
-
- //public boolean isEntityParsed(int index);
- //public boolean isEntityExternal(int index);
-
- //public String getEntityPublicId(int index);
- //public String getEntitySystemId(int index);
- //public String getNotationIdOfEntity(int entityIndex);
- //public String getEntityExpansionText(int index);
-
- /*
- //////////////////////////////////////////////////////////
- // Notation support
- //////////////////////////////////////////////////////////
- */
-
- /**
- * @return Number of notations declared in this DTD
- * schema (in subsets [internal, external] included)
- */
- public int getNotationCount();
-
- //public boolean isNotationDefined(String name);
-
- /**
- * @return Index of the notation with given name (between 0 and
- * getNotationtyCount()-1
)
- * if such notation was defined in this dtd; -1 if not.
- */
- //public int findNotation(String name);
-
- //public String getNotationName(int index);
- //public String getNotationPublicId(int index);
- //public String getNotationSystemId(int index);
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/Validatable.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/Validatable.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/Validatable.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/Validatable.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,72 +0,0 @@
-package org.codehaus.stax2.validation;
-
-import javax.xml.stream.XMLStreamException;
-
-/**
- * Interface that defines API that Stax2 validation system exposes to the
- * applications. It is implemented by stream readers and writers.
- *
- * Interface defines methods for starting and stopping - * validation against specific schemas, or validator instances, as well - * as method(s) for adding an optional custom problem handler. - */ -public interface Validatable -{ - /** - * Method that will construct a {@link XMLValidator} instance from the - * given schema (unless a validator for that schema has already been - * added), - * initialize it if necessary, and make validatable object (reader, - * writer) - * call appropriate validation methods from this point on until the - * end of the document (that is, it's not scoped with sub-trees), or until - * validator is removed by an explicit call to - * {@link #stopValidatingAgainst}. - *
- * Note that while this method can be called at any point in output - * processing, validator instances are not required to be able to handle - * addition at other points than right before outputting the root element. - * - * @return Validator instance constructed, if validator was added, or null - * if a validator for the schema has already been constructed. - */ - public XMLValidator validateAgainst(XMLValidationSchema schema) - throws XMLStreamException; - - /** - * Method that can be called by application to stop validating - * output against a schema, for which {@link #validateAgainst} - * was called earlier. - * - * @return Validator instance created from the schema that was removed, - * if one was in use; null if no such schema in use. - */ - public XMLValidator stopValidatingAgainst(XMLValidationSchema schema) - throws XMLStreamException; - - /** - * Method that can be called by application to stop validating - * output using specified validator. The validator passed should be - * an earlier return value for a call to {@link #validateAgainst}. - *
- * Note: the specified validator is compared for identity with validators
- * in use, not for equality.
- *
- * @return Validator instance found (ie. argument validator
)
- * if it was being used for validating current document; null if not.
- */
- public XMLValidator stopValidatingAgainst(XMLValidator validator)
- throws XMLStreamException;
-
- /**
- * Method that application can call to define a custom handler for
- * validation problems encountered during validation process.
- *
- * @param h Handler to install, if non null; if null, indicates that
- * the default (implementation-specific) handling should be used
- *
- * @return Previously set validation problem handler, if any; null
- * if none was set
- */
- public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h);
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/ValidationContext.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/ValidationContext.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/ValidationContext.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/ValidationContext.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,190 +0,0 @@
-package org.codehaus.stax2.validation;
-
-import javax.xml.namespace.QName;
-import javax.xml.stream.Location;
-import javax.xml.stream.XMLStreamException;
-
-/**
- * Interface that defines functionality exposed by the "owner" of the
- * content to validate (usually a stream reader or stream writer) to
- * validators, needed in addition to actually validatable content, for
- * succesful validation. It also defines methods needed for infoset
- * augmentation some validators do, such as adding default values
- * to attributes.
- * Some of functionality is optional (for example, writer
- * may not have any useful location information).
- *
- * The functionality included is close to the minimal subset of - * functionality needed to support 3 main streamable schema languages - * (DTD, W3C Schema, Relax NG). - */ -public interface ValidationContext -{ - /* - /////////////////////////////////////////////////////////////////////// - // Basic configuration - /////////////////////////////////////////////////////////////////////// - */ - - /** - * Method that validator can call to figure out which xml version - * document being validated declared (if none, "1.0" is assumed as - * per xml specifications 1.0 and 1.1). - * - * @return Xml version of the document: currently has to be either - * "1.0" or "1.1". - */ - public String getXmlVersion(); - - /* - /////////////////////////////////////////////////////////////////////// - // Input element stack access - /////////////////////////////////////////////////////////////////////// - */ - - /** - * Method that can be used to access name information of the - * innermost (top) element in the element stack. - * - * @return Name of the element at the top of the current element - * stack, if any. During validation calls it refers to the - * element being processed (start or end tag), or its parent - * (when processing text nodes), or null (in document prolog - * and epilog). - */ - public QName getCurrentElementName(); - - /** - * Method that can be called by the validator to resolve a namespace - * prefix of the currently active top-level element. This may be - * necessary for things like DTD validators (which may need to - * heuristically guess proper namespace URI of attributes, esp. - * ones with default values). - */ - public String getNamespaceURI(String prefix); - - /** - * This method returns number of attributes accessible from within - * currently active start element. - *
- * Note: this method is only guaranteed to be callable during execution - * of {@link XMLValidator} methods - * {@link XMLValidator#validateElementStart}, - * {@link XMLValidator#validateAttribute} and - * {@link XMLValidator#validateElementAndAttributes}. At other times - * implementations may choose to allow it to be called (for example, - * with information regarding last start element processed), to throw - * a {@link IllegalArgumentException}, or to return 0 to indicate no - * attribute information is available. - *
- * Also note that whether defaulted attributes (attributes for which - * values are only available via attribute defaulting) are accessible - * depends on exact time when this method is called, and in general - * can not be assumed to function reliably. - * - * @return Number of attributes accessible for the currently active - * start element. - */ - public int getAttributeCount(); - - public String getAttributeLocalName(int index); - - public String getAttributeNamespace(int index); - - public String getAttributePrefix(int index); - - public String getAttributeValue(int index); - - public String getAttributeValue(String nsURI, String localName); - - public String getAttributeType(int index); - - /** - * @return Index of the specified attribute, if one present; - * -1 otherwise. - */ - public int findAttributeIndex(String nsURI, String localName); - - /* - /////////////////////////////////////////////////////////////////////// - // Access to notation and unparsed entity information - /////////////////////////////////////////////////////////////////////// - */ - - /** - * @return True, if a notation with specified name has been declared - * in the document being validated; false if not. - */ - public boolean isNotationDeclared(String name); - - /** - * @return True, if an unparsed entity with specified name has - * been declared - * in the document being validated; false if not. - */ - public boolean isUnparsedEntityDeclared(String name); - - /* - /////////////////////////////////////////////////////////////////////// - // Location information, error reporting - ////////////////////////////////////////////////////// - */ - - /** - * @return Base URI active in the current location of the document - * being validated, if known; null to indicate no base URI known. - */ - public String getBaseUri(); - - /** - * Method that will return the location that best represents current - * location within document to be validated, if such information - * is available. - *
- * Note: it is likely that even when a location is known, it may not - * be very accurate; for example, when attributes are validated, it - * is possible that they all would point to a single location that - * may point to the start of the element that contains attributes. - */ - public Location getValidationLocation(); - - /** - * Method called by the validator, upon encountering a validation - * problem. Implementations are encouraged to allow an optional - * {@link ValidationProblemHandler} be set by the application, - * to define handling. - *
- * Note: Stax2 version 2 only allowed throwing instances - * of {@link XMLValidationProblem}; version 3 allows generic - * base class to be thrown, to support other interfaces such - * as basic Stax interface {@link javax.xml.stream.XMLReporter}. - */ - public void reportProblem(XMLValidationProblem problem) - throws XMLStreamException; - - /* - /////////////////////////////////////////////////////////////////////// - // Infoset modifiers - /////////////////////////////////////////////////////////////////////// - */ - - /** - * An optional method that can be used to add a new attribute value for - * an attribute - * that was not yet contained by the container, as part of using attribute - * default value mechanism. Optional here means that it is possible that - * no operation is actually done by the context object. This would be - * the case, for example, when validation is done on the writer side: - * since default attributes are implied by a DTD, they should not be - * added to the output. - *
- * Note: caller has to ensure that the addition would not introduce a - * duplicate; attribute container implementation is not required to do - * any validation on attribute name (local name, prefix, uri) or value. - * - * @return Index of the newly added attribute, if operation was - * succesful; -1 if not. - */ - public int addDefaultAttribute(String localName, String uri, String prefix, - String value); -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/ValidationProblemHandler.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/ValidationProblemHandler.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/ValidationProblemHandler.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/ValidationProblemHandler.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,22 +0,0 @@ -package org.codehaus.stax2.validation; - -/** - * This interface defines method(s) needed to implement a custom validation - * problem (warning, error, fatal error) handler. Such handlers can be used, - * for example, to collect validation problems without automatically - * throwing exceptions. It can also be used to throw exception for problems - * that by default would only be reported as warnings. - */ -public interface ValidationProblemHandler -{ - /** - * Method called by validator, when a validation problem is encountered. - * Impementations can choose to ignore the problem, log something about - * the problem, store it for later processing, or throw - * a {@link XMLValidationException}. - * - * @param problem Validation problem encountered. - */ - public void reportProblem(XMLValidationProblem problem) - throws XMLValidationException; -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/ValidatorPair.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/ValidatorPair.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/ValidatorPair.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/ValidatorPair.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,264 +0,0 @@ -package org.codehaus.stax2.validation; - -import javax.xml.stream.XMLStreamException; - -/** - * Simple utility class that allows chaining of {@link XMLValidator} - * instances. Since the class itself implements {@link XMLValidator}, - * multiple validators can be added by chaining these pairs; ordering - * of validator calls depends on ordering of the pairs. - *
- * Default semantics are quite simple: first validator of the pair is - * always called first, and results as/if modified by that validator - * are passed on to the second validator. - *
- * It is expected that this class is mostly used by actual stream reader - * and writer implementations; not so much by validator implementations. - */ -public class ValidatorPair - extends XMLValidator -{ - public final static String ATTR_TYPE_DEFAULT = "CDATA"; - - protected XMLValidator mFirst, mSecond; - - /* - //////////////////////////////////////////////////// - // Life-cycle - //////////////////////////////////////////////////// - */ - - public ValidatorPair(XMLValidator first, XMLValidator second) - { - mFirst = first; - mSecond = second; - } - - /* - //////////////////////////////////////////////////// - // XMLValidator implementation - //////////////////////////////////////////////////// - */ - - /** - * Two choices here; could either return schema of the first child, - * or return null. Let's do latter, do avoid accidental matches. - */ - public XMLValidationSchema getSchema() - { - return null; - } - - public void validateElementStart(String localName, String uri, - String prefix) - throws XMLStreamException - { - mFirst.validateElementStart(localName, uri, prefix); - mSecond.validateElementStart(localName, uri, prefix); - } - - public String validateAttribute(String localName, String uri, - String prefix, String value) - throws XMLStreamException - { - String retVal = mFirst.validateAttribute(localName, uri, prefix, - value); - if (retVal != null) { - value = retVal; - } - return mSecond.validateAttribute(localName, uri, prefix, value); - } - - public String validateAttribute(String localName, String uri, - String prefix, - char[] valueChars, int valueStart, - int valueEnd) - throws XMLStreamException - { - String retVal = mFirst.validateAttribute(localName, uri, prefix, - valueChars, valueStart, valueEnd); - /* If it got normalized, let's pass normalized value to the second - * validator - */ - if (retVal != null) { - return mSecond.validateAttribute(localName, uri, prefix, retVal); - } - // Otherwise the original - return mSecond.validateAttribute(localName, uri, prefix, - valueChars, valueStart, valueEnd); - } - - public int validateElementAndAttributes() - throws XMLStreamException - { - int textType1 = mFirst.validateElementAndAttributes(); - int textType2 = mSecond.validateElementAndAttributes(); - - /* Here, let's choose the stricter (more restrictive) of the two. - * Since constants are order from strictest to most lenient, - * we'll just take smaller of values - */ - return (textType1 < textType2) ? textType1 : textType2; - } - - public int validateElementEnd(String localName, String uri, String prefix) - throws XMLStreamException - { - int textType1 = mFirst.validateElementEnd(localName, uri, prefix); - int textType2 = mSecond.validateElementEnd(localName, uri, prefix); - - // As with earlier, let's return stricter of the two - return (textType1 < textType2) ? textType1 : textType2; - } - - public void validateText(String text, boolean lastTextSegment) - throws XMLStreamException - { - mFirst.validateText(text, lastTextSegment); - mSecond.validateText(text, lastTextSegment); - } - - public void validateText(char[] cbuf, int textStart, int textEnd, - boolean lastTextSegment) - throws XMLStreamException - { - mFirst.validateText(cbuf, textStart, textEnd, lastTextSegment); - mSecond.validateText(cbuf, textStart, textEnd, lastTextSegment); - } - - public void validationCompleted(boolean eod) - throws XMLStreamException - { - mFirst.validationCompleted(eod); - mSecond.validationCompleted(eod); - } - - /* - /////////////////////////////////////////////////// - // Access to post-validation data (type info) - /////////////////////////////////////////////////// - */ - - public String getAttributeType(int index) - { - String type = mFirst.getAttributeType(index); - /* Hmmh. Which heuristic to use here: obviously no answer (null or - * empty) is not useful. But what about the default type (CDATA)? - * We can probably find a more explicit type? - */ - if (type == null || type.length() == 0 || type.equals(ATTR_TYPE_DEFAULT)) { - String type2 = mSecond.getAttributeType(index); - if (type2 != null && type2.length() > 0) { - return type2; - } - - } - return type; - } - - public int getIdAttrIndex() - { - int index = mFirst.getIdAttrIndex(); - if (index < 0) { - return mSecond.getIdAttrIndex(); - } - return index; - } - - public int getNotationAttrIndex() - { - int index = mFirst.getNotationAttrIndex(); - if (index < 0) { - return mSecond.getNotationAttrIndex(); - } - return index; - } - - /* - //////////////////////////////////////////////////// - // Additional API used by Woodstox core - //////////////////////////////////////////////////// - */ - - public static boolean removeValidator(XMLValidator root, XMLValidationSchema schema, XMLValidator[] results) - { - if (root instanceof ValidatorPair) { - return ((ValidatorPair) root).doRemoveValidator(schema, results); - } else { - if (root.getSchema() == schema) { - results[0] = root; - results[1] = null; - return true; - } - } - return false; - } - - public static boolean removeValidator(XMLValidator root, XMLValidator vld, XMLValidator[] results) - { - if (root == vld) { // single validator? - results[0] = root; - results[1] = null; - return true; - } else if (root instanceof ValidatorPair) { - return ((ValidatorPair) root).doRemoveValidator(vld, results); - } - return false; - } - - private boolean doRemoveValidator(XMLValidationSchema schema, XMLValidator[] results) - { - if (removeValidator(mFirst, schema, results)) { - XMLValidator newFirst = results[1]; - if (newFirst == null) { // removed first (was leaf) -> remove this pair - results[1] = mSecond; - } else { - mFirst = newFirst; // two may be the same, need not be - results[1] = this; - } - return true; - } - if (removeValidator(mSecond, schema, results)) { - XMLValidator newSecond = results[1]; - if (newSecond == null) { // removed second (was leaf) -> remove this pair - results[1] = mFirst; - } else { - mSecond = newSecond; // two may be the same, need not be - results[1] = this; // will still have this pair - } - return true; - } - return false; - } - - private boolean doRemoveValidator(XMLValidator vld, XMLValidator[] results) - { - if (removeValidator(mFirst, vld, results)) { - XMLValidator newFirst = results[1]; - if (newFirst == null) { // removed first (was leaf) -> remove this pair - results[1] = mSecond; - } else { - mFirst = newFirst; // two may be the same, need not be - results[1] = this; - } - return true; - } - if (removeValidator(mSecond, vld, results)) { - XMLValidator newSecond = results[1]; - if (newSecond == null) { // removed second (was leaf) -> remove this pair - results[1] = mFirst; - } else { - mSecond = newSecond; // two may be the same, need not be - results[1] = this; // will still have this pair - } - return true; - } - return false; - } - - /* - //////////////////////////////////////////////////// - // Internal methods - //////////////////////////////////////////////////// - */ -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidationException.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidationException.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidationException.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidationException.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,88 +0,0 @@ -package org.codehaus.stax2.validation; - -import javax.xml.stream.Location; -import javax.xml.stream.XMLStreamException; - -/** - * Specialized sub-class of {@link XMLStreamException}, to be used for - * indicating fatal validation problems (when in mode in which exceptions - * are to be thrown). - *
- * Note: constructors are protected, since direct instantiation should - * be done using factory methods. Reason for this is that the base - * {@link XMLStreamException} has less than robust handling of optional - * arguments, and thus factory methods of this class can take care to - * choose appropriate constructors to call, to make sure super-class does - * not barf (NPE or such). - */ -public class XMLValidationException - extends XMLStreamException -{ - private static final long serialVersionUID = 1L; - - protected XMLValidationProblem mCause; - - // // Constructors are protected; sub-classes need to know what - // // they are doing - - protected XMLValidationException(XMLValidationProblem cause) - { - super(); - if (cause == null) { - throwMissing(); - } - mCause = cause; - } - - protected XMLValidationException(XMLValidationProblem cause, String msg) - { - super(msg); - if (cause == null) { - throwMissing(); - } - mCause = cause; - } - - protected XMLValidationException(XMLValidationProblem cause, String msg, - Location loc) - { - super(msg, loc); - if (cause == null) { - throwMissing(); - } - mCause = cause; - } - - // // // Factory methods - - public static XMLValidationException createException(XMLValidationProblem cause) - { - String msg = cause.getMessage(); - if (msg == null) { - return new XMLValidationException(cause); - } - Location loc = cause.getLocation(); - if (loc == null) { - return new XMLValidationException(cause, msg); - } - return new XMLValidationException(cause, msg, loc); - } - - // // // Accessors - - /** - * @return Object that has all information about details of the - * validation problem - */ - public XMLValidationProblem getValidationProblem() { - return mCause; - } - - // // // Internal - - protected static void throwMissing() - throws RuntimeException - { - throw new IllegalArgumentException("Validation problem argument can not be null"); - } -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidationProblem.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidationProblem.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidationProblem.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidationProblem.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,123 +0,0 @@ -package org.codehaus.stax2.validation; - -import javax.xml.stream.Location; - -/** - * Simple container class used to store a non-fatal problem - * either to be returned as is, or to use for creating and throwing - * a validation exception. - */ -public class XMLValidationProblem -{ - public final static int SEVERITY_WARNING = 1; - public final static int SEVERITY_ERROR = 2; - public final static int SEVERITY_FATAL = 3; - - /** - * Location within validated xml stream where the problem occured. - */ - protected Location mLocation; - - protected final String mMessage; - - protected final int mSeverity; - - /** - * Type of the problem, available types implementation specified. - * - * @since 3.0 - */ - protected String mType; - - /** - * Validator instance that reported the problem, if any (may be - * null if stream reader or writer itself reported the problem) - * - * @since 3.0 - */ - protected XMLValidator mReporter; - - public XMLValidationProblem(Location loc, String msg) - { - this(loc, msg, SEVERITY_ERROR); - } - - public XMLValidationProblem(Location loc, String msg, int severity) - { - this(loc, msg, severity, null); - } - - public XMLValidationProblem(Location loc, String msg, int severity, - String type) - { - mLocation = loc; - mMessage = msg; - mSeverity = severity; - mType = type; - } - - /** - * Convenience method for constructing a {@link XMLValidationException} - * to throw based on information contained in this object. - * Base implementation is equivalent to: - *
- * return XMLValidationException.createException(this); - *- * - * @since 3.0 - */ - public XMLValidationException toException() - { - return XMLValidationException.createException(this); - } - - /** - * @since 3.0 - */ - public void setType(String t) { mType = t; } - - /** - * @since 3.0 - */ - public void setLocation(Location l) { mLocation = l; } - - /** - * Set the validator object that reported this problem, if known. - * - * @since 3.0 - */ - public void setReporter(XMLValidator v) { mReporter = v; } - - /** - * @return Reference to location where problem was encountered. - */ - public Location getLocation() { return mLocation; } - - /** - * @return Human-readable message describing the problem - */ - public String getMessage() { return mMessage; } - - /** - * @return One of
SEVERITY_
constants
- * (such as {@link #SEVERITY_WARNING}
- */
- public int getSeverity() { return mSeverity; }
-
- /**
- * @return Generic type (class) of the problem; may be null
- * if validator does not provide such details
- *
- * @since 3.0
- */
- public String getType() { return mType; }
-
- /**
- * Returns the validator that reported the problem if known.
- *
- * @return Validator that reported the problem; null if unknown or N/A.
- *
- * @since 3.0
- */
- public XMLValidator getReporter() { return mReporter; }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidationSchemaFactory.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidationSchemaFactory.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidationSchemaFactory.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidationSchemaFactory.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,315 +0,0 @@
-package org.codehaus.stax2.validation;
-
-import java.io.*;
-import java.net.URL;
-import java.util.*;
-
-import javax.xml.stream.FactoryConfigurationError;
-import javax.xml.stream.XMLStreamException;
-
-/**
- * Defines an abstract factory for constructing {@link XMLValidationSchema}
- * instances. This abstract base class has methods for instantiating the
- * actual implementation (similar to the way
- * {@link javax.xml.stream.XMLInputFactory} works, and defines the API to
- * use for configuring these instances, as well as factory methods concrete
- * classes implement for actually creating {@link XMLValidationSchema}
- * instances.
- *- * Note: this class is part of the second major revision of StAX 2 API - * (StAX2, v2), and is optional for StAX2 implementations to support. - * - * @see javax.xml.stream.XMLInputFactory - * @see org.codehaus.stax2.validation.XMLValidationSchema - * @see org.codehaus.stax2.XMLInputFactory2 - */ -public abstract class XMLValidationSchemaFactory -{ - // // // Internal ids matching SCHEMA_ID_ constants from XMLValidationSchema - - public final static String INTERNAL_ID_SCHEMA_DTD = "dtd"; - public final static String INTERNAL_ID_SCHEMA_RELAXNG = "relaxng"; - public final static String INTERNAL_ID_SCHEMA_W3C = "w3c"; - public final static String INTERNAL_ID_SCHEMA_TREX = "trex"; - - final static HashMap sSchemaIds = new HashMap(); - static { - sSchemaIds.put(XMLValidationSchema.SCHEMA_ID_DTD, INTERNAL_ID_SCHEMA_DTD); - sSchemaIds.put(XMLValidationSchema.SCHEMA_ID_RELAXNG, INTERNAL_ID_SCHEMA_RELAXNG); - sSchemaIds.put(XMLValidationSchema.SCHEMA_ID_W3C_SCHEMA, INTERNAL_ID_SCHEMA_W3C); - sSchemaIds.put(XMLValidationSchema.SCHEMA_ID_TREX, INTERNAL_ID_SCHEMA_TREX); - } - - - // // // Properties for locating implementations - - /** - * Name of resource file that contains JAXP properties. - */ - final static String JAXP_PROP_FILENAME = "jaxp.properties"; - - /** - * Defines the system property that can be set to explicitly specify - * which implementation to use (in case there are multiple StAX2 - * implementations; or the one used does not specify other mechanisms - * for the loader to find the implementation class). - */ - public final static String SYSTEM_PROPERTY_FOR_IMPL = "org.codehaus.stax2.validation.XMLValidationSchemaFactory."; - - /** - * Path to resource that should contain implementation class definition. - */ - public final static String SERVICE_DEFINITION_PATH = "META-INF/services/" + SYSTEM_PROPERTY_FOR_IMPL; - - // // // Names of standard configuration properties - - /** - * Property that determines whether schemas constructed are namespace-aware, - * in cases where schema supports both namespace-aware and non-namespace - * aware modes. In general this only applies to DTDs, since namespace - * support for DTDs is both optional, and not well specified. - *
- * Default value is TRUE. For schema types for which only one value
- * (usually TRUE) is allowed, this property will be ignored.
- */
- public static final String P_IS_NAMESPACE_AWARE = "org.codehaus2.stax2.validation.isNamespaceAware";
-
- /**
- * Property that determines whether schema instances created by this
- * factory instance can be cached by the factory; if false, no caching
- * is allowed to be doe; if true, factory can do caching if it wants to.
- * The exact rules used to determine unique id of schema instances is
- * factory dependant; it is expected that the implementations use
- * implementation based on unified system ids (serialized URLs or such).
- */
- public static final String P_ENABLE_CACHING = "org.codehaus2.stax2.validation.enableCaching";
-
- /**
- * Schema type this factory instance supports.
- */
- protected final String mSchemaType;
-
- /**
- * @param st Schema type this factory supports; one of
- * SCHEMA_ID_xxx
constants.
- */
- protected XMLValidationSchemaFactory(String st)
- {
- mSchemaType = st;
- }
-
- /*
- ////////////////////////////////////////////////////////
- // Factory methods
- ////////////////////////////////////////////////////////
- */
-
- // // // First creating the factory instances:
-
- /**
- * Creates a new XMLValidationFactory instance, using the default
- * instance configuration mechanism.
- */
- public static XMLValidationSchemaFactory newInstance(String schemaType)
- throws FactoryConfigurationError
- {
- return newInstance(schemaType,
- Thread.currentThread().getContextClassLoader());
- }
-
- public static XMLValidationSchemaFactory newInstance(String schemaType, ClassLoader classLoader)
- throws FactoryConfigurationError
- {
- /* First, let's check and map schema type to the shorter internal
- * id:
- */
- String internalId = (String) sSchemaIds.get(schemaType);
- if (internalId == null) {
- throw new FactoryConfigurationError("Unrecognized schema type (id '"+schemaType+"')");
- }
-
- String propertyId = SYSTEM_PROPERTY_FOR_IMPL + internalId;
- SecurityException secEx = null;
-
- /* First, let's see if there's a system property (overrides other
- * settings)
- */
- try {
- String clsName = System.getProperty(propertyId);
- if (clsName != null && clsName.length() > 0) {
- return createNewInstance(classLoader, clsName);
- }
- } catch (SecurityException se) {
- // May happen on sandbox envs, like applets?
- secEx = se;
- }
-
- /* try to read from $java.home/lib/xml.properties (simulating
- * the way XMLInputFactory does this... not sure if this should
- * be done, as this is not [yet?] really jaxp specified)
- */
- try {
- String home = System.getProperty("java.home");
- File f = new File(home);
-
- // Let's not hard-code separators...
- f = new File(f, "lib");
- f = new File(f, JAXP_PROP_FILENAME);
- if (f.exists()) {
- try {
- Properties props = new Properties();
- props.load(new FileInputStream(f));
- String clsName = props.getProperty(propertyId);
- if (clsName != null && clsName.length() > 0) {
- return createNewInstance(classLoader, clsName);
- }
- } catch (IOException ioe) {
- // can also happen quite easily...
- }
- }
- } catch (SecurityException se) {
- // Fine, as above
- secEx = se;
- }
-
- /* Ok, no match; how about a service def from the impl jar?
- */
- // try to find services in CLASSPATH
- String path = SERVICE_DEFINITION_PATH + internalId;
- try {
- Enumeration en;
-
- if (classLoader == null) {
- en = ClassLoader.getSystemResources(path);
- } else {
- en = classLoader.getResources(path);
- }
-
- if (en != null) {
- while (en.hasMoreElements()) {
- URL url = (URL) en.nextElement();
- InputStream is = url.openStream();
- BufferedReader rd =
- new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
- String clsName = null;
- String line;
-
- try {
- while ((line = rd.readLine()) != null) {
- line = line.trim();
- if (line.length() > 0 && line.charAt(0) != '#') {
- clsName = line;
- break;
- }
- }
- } finally {
- rd.close();
- }
- if (clsName != null && clsName.length() > 0) {
- return createNewInstance(classLoader, clsName);
- }
- }
- }
- } catch (SecurityException se) {
- secEx = se;
- } catch (IOException ex) {
- /* Let's assume these are mostly ok, too (missing jar ie.)
- */
- }
-
- String msg = "No XMLValidationSchemaFactory implementation class specified or accessible (via system property '"
- +propertyId+"', or service definition under '"+path+"')";
-
- if (secEx != null) {
- throw new FactoryConfigurationError(msg + " (possibly caused by: "+secEx+")", secEx);
- }
- throw new FactoryConfigurationError(msg);
- }
-
- // // // And then actual per-instance factory methods
-
- public XMLValidationSchema createSchema(InputStream in)
- throws XMLStreamException
- {
- return createSchema(in, null);
- }
-
- public XMLValidationSchema createSchema(InputStream in, String encoding)
- throws XMLStreamException
- {
- return createSchema(in, encoding, null, null);
- }
-
- public abstract XMLValidationSchema createSchema(InputStream in, String encoding,
- String publicId, String systemId)
- throws XMLStreamException;
-
- public XMLValidationSchema createSchema(Reader r)
- throws XMLStreamException
- {
- return createSchema(r, null, null);
- }
-
- public abstract XMLValidationSchema createSchema(Reader r, String publicId,
- String systemId)
- throws XMLStreamException;
-
- public abstract XMLValidationSchema createSchema(URL url)
- throws XMLStreamException;
-
- public abstract XMLValidationSchema createSchema(File f)
- throws XMLStreamException;
-
- /*
- ////////////////////////////////////////////////////////
- // Configuration
- ////////////////////////////////////////////////////////
- */
-
- public abstract boolean isPropertySupported(String propName);
-
- /**
- * @param propName Name of property to set
- * @param value Value to set property to
- *
- * @return True if setting succeeded; false if property was recognized
- * but could not be changed to specified value, or if it was not
- * recognized but the implementation did not throw an exception.
- */
- public abstract boolean setProperty(String propName, Object value);
-
- public abstract Object getProperty(String propName);
-
- /**
- * @return Name of schema type (one of SCHEMA_ID_xxx
- * constants) that this factory supports.
- */
- public final String getSchemaType() { return mSchemaType; }
-
- /*
- ///////////////////////////////////////////////////////
- // Internal methods
- ///////////////////////////////////////////////////////
- */
-
- private static XMLValidationSchemaFactory createNewInstance(ClassLoader cloader, String clsName)
- throws FactoryConfigurationError
- {
- try {
- Class factoryClass;
-
- if (cloader == null) {
- factoryClass = Class.forName(clsName);
- } else {
- factoryClass = cloader.loadClass(clsName);
- }
- return (XMLValidationSchemaFactory) factoryClass.newInstance();
- } catch (ClassNotFoundException x) {
- throw new FactoryConfigurationError
- ("XMLValidationSchemaFactory implementation '"+clsName+"' not found (missing jar in classpath?)", x);
- } catch (Exception x) {
- throw new FactoryConfigurationError
- ("XMLValidationSchemaFactory implementation '"+clsName+"' could not be instantiated: "+x, x);
- }
- }
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidationSchema.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidationSchema.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidationSchema.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidationSchema.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,49 +0,0 @@
-package org.codehaus.stax2.validation;
-
-import javax.xml.stream.XMLStreamException;
-
-/**
- * Defines the API that validator schema instances have to implement. Schema
- * objects are results of parsing of input that defines validation rules;
- * things like DTD files, W3c Schema input documents and so on. Schema
- * instances can not be directly used for validation; they are blueprints
- * for constructing such validator Objects. Because of this, they are
- * also guaranteed to be thread-safe and reusable. One way to think of this
- * is that schemas are actual validator factories instead of
- * {@link XMLValidationSchemaFactory} instances.
- *
- * One note about creation of validator instances: since the validation - * may be invoked from wide variety of contexts (from parser, from serializer, - * from processing pipeline etc), the validation context is abstracted - * as {@link ValidationContext}. Instances may make use of additional - * knowledge about actual implementing classes if they can safely determine - * the type runtime, but should gracefully handle the cases where - * the context is created by a caller that is not part of the same - * StAX implementation as the validator. - */ -public interface XMLValidationSchema -{ - // // // Constants defining standard Schema types: - - public final static String SCHEMA_ID_DTD = "http://www.w3.org/XML/1998/namespace"; - public final static String SCHEMA_ID_RELAXNG = "http://relaxng.org/ns/structure/0.9"; - public final static String SCHEMA_ID_W3C_SCHEMA = "http://www.w3.org/2001/XMLSchema"; - public final static String SCHEMA_ID_TREX = "http://www.thaiopensource.com/trex"; - - public XMLValidator createValidator(ValidationContext ctxt) - throws XMLStreamException; - - /* - /////////////////////////////////////////////////// - // Configuration, properties - /////////////////////////////////////////////////// - */ - - /** - * Returns type of this schema. - * - * @return One of external schema identifier values (such as - * {@link #SCHEMA_ID_DTD}). - */ - public String getSchemaType(); -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidator.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidator.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/validation/XMLValidator.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/validation/XMLValidator.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,286 +0,0 @@ -package org.codehaus.stax2.validation; - -import javax.xml.stream.XMLStreamException; - -/** - * Class that defines interface that individual (possibly) stateful validator - * instances have to implement, and that both - * {@link javax.xml.stream.XMLStreamReader} and - * {@link javax.xml.stream.XMLStreamWriter} instances can call to validate - * xml documents. - *
- * Validator instances are created from and by non-stateful - * {@link XMLValidationSchema} instances. A new validator instance has to - * be created for each document read or written, ie. can not be shared - * or reused, unlike schema instances which can be. - */ -public abstract class XMLValidator -{ - // // // Shared constants - - /* First, constants used by validators to indicate kind of pre-validation - * (with respect to text, and in some cases, other non-element events) - * caller needs to take, before calling the validator. The idea is to - * allow stream readers and writers to do parts of validity checks they - * are in best position to do, while leaving the real structural and - * content-based validation to validators. - */ - - /** - * This value indicates that no content whatsoever - * is legal within current context, that is, where the only legal content - * to follow is the closing end tag -- not even comments or processing - * instructions are allowed. This is the case for example for - * elements that DTD defines to have EMPTY content model. - *
- */ - public final static int CONTENT_ALLOW_NONE = 0; - - /** - * This value indicates that only white space text content is allowed, - * not other kinds of text. Other non-text events may be allowed; - * validator will deal with element validation. - * Value also indicates that if non-white space text content is - * encountered, a validation problem is reported - */ - public final static int CONTENT_ALLOW_WS = 1; - - /** - * This value is similar to {@link #CONTENT_ALLOW_WS_NONSTRICT}, - * but only used for content typing purposes, not for validation. - * This means that if non-white space text content is encountered, - * no problem is reported. - *
- * This value is currently only used with DTD processors, when in
- * typing (non-validating) mode.
- *
- * @since 3.0
- */
- public final static int CONTENT_ALLOW_WS_NONSTRICT = 2;
-
- /**
- * This value indicates that textual content is allowed, but that
- * the validator needs to be called to let it do actual content-based
- * validation. Other event types are ok, and elements will need to be
- * validated by the validator as well.
- */
- public final static int CONTENT_ALLOW_VALIDATABLE_TEXT = 3;
-
- /**
- * This value indicates that any textual content (plain PCTEXT) is
- * allowed, and that validator is not going to do any validation
- * for it. It will, however, need to be called with respect
- * to element events.
- */
- public final static int CONTENT_ALLOW_ANY_TEXT = 4;
-
- /**
- * This value is a placeholder that should never be returned by
- * validators, but that can be used internally as an uninitialized
- * value.
- */
- public final static int CONTENT_ALLOW_UNDEFINED = 5;
-
- /*
- ///////////////////////////////////////////////////
- // Life-cycle
- ///////////////////////////////////////////////////
- */
-
- protected XMLValidator() { }
-
- /*
- ///////////////////////////////////////////////////
- // Configuration, properties
- ///////////////////////////////////////////////////
- */
-
- /**
- * Returns type of schema that was used to construct this
- * validator instance.
- *
- * @return One of external schema identifier values (such as
- * {@link XMLValidationSchema#SCHEMA_ID_DTD}).
- */
- public String getSchemaType() {
- XMLValidationSchema sch = getSchema();
- return (sch == null) ? null : sch.getSchemaType();
- }
-
- /**
- * Returns the schema instance that created this validator
- * object, if known (and applicable). May return null for
- * some instances: specifically, {@link ValidatorPair}
- * will return null since it 'contains' multiple validators
- * and generally does not have just one parent or owner schema.
- */
- public abstract XMLValidationSchema getSchema();
-
- /*
- ///////////////////////////////////////////////////
- // Actual validation interface
- ///////////////////////////////////////////////////
- */
-
- public abstract void validateElementStart(String localName, String uri,
- String prefix)
- throws XMLStreamException;
-
- /**
- * Callback method called on validator to give it a chance to validate
- * the value of an attribute, as well as to normalize its value if
- * appropriate (remove leading/trailing/intervening white space for
- * certain token types etc.).
- *
- * @return Null, if the passed value is fine as is; or a String, if
- * it needs to be replaced. In latter case, caller will replace the
- * value before passing it to other validators. Also, if the attribute
- * value is accessible via caller (as is the case for stream readers),
- * caller should return this value, instead of the original one.
- */
- public abstract String validateAttribute(String localName, String uri,
- String prefix, String value)
- throws XMLStreamException;
-
- /**
- * Callback method called on validator to give it a chance to validate
- * the value of an attribute, as well as to normalize its value if
- * appropriate (remove leading/trailing/intervening white space for
- * certain token types etc.).
- *
- * @param valueChars Character array that contains value (possibly
- * along with some other text)
- * @param valueStart Index of the first character of the value in
- * in valueChars
array
- * @param valueEnd Index of the character AFTER the last character;
- * so that the length of the value String is
- * valueEnd - valueStart
- *
- * @return Null, if the passed value is fine as is; or a String, if
- * it needs to be replaced. In latter case, caller will replace the
- * value before passing it to other validators. Also, if the attribute
- * value is accessible via caller (as is the case for stream readers),
- * caller should return this value, instead of the original one.
- */
- public abstract String validateAttribute(String localName, String uri,
- String prefix,
- char[] valueChars, int valueStart,
- int valueEnd)
- throws XMLStreamException;
-
- /**
- * Method called after calling {@link #validateAttribute} on all
- * attributes (if any), but before starting to handle element
- * content.
- *
- * @return One of CONTENT_ALLOW_
constants, to indicate
- * what kind of textual content is allowed at the scope returned
- * to after the element has closed.
- */
- public abstract int validateElementAndAttributes()
- throws XMLStreamException;
-
- /**
- * Method called right after encountering an element close tag.
- *
- * @return One of CONTENT_ALLOW_
constants, to indicate
- * what kind of textual content is allowed at the scope returned
- * to after the element has closed.
- */
- public abstract int validateElementEnd(String localName, String uri,
- String prefix)
- throws XMLStreamException;
-
- /**
- * Method called to validate textual content.
- *
- * Note: this method is only guaranteed to be called when - * {@link #validateElementAndAttributes()} for the currently open - * element returned {@link #CONTENT_ALLOW_VALIDATABLE_TEXT} (or, - * in case of mixed content, {@link #validateElementEnd}, for the - * last enclosed element). Otherwise, validator context may choose - * not to call the method as an optimization. - * - * @param text Text content to validate - * @param lastTextSegment Whether this text content is the last text - * segment before a close element; true if it is, false if it is not, - * or no determination can be made. Can be used for optimizing - * validation -- if this is true, no text needs to be buffered since - * no more will be sent before the current element closes. - */ - public abstract void validateText(String text, boolean lastTextSegment) - throws XMLStreamException; - - /** - * Method called to validate textual content. - *
- * Note: this method is only guaranteed to be called when
- * {@link #validateElementAndAttributes()} for the currently open
- * element returned {@link #CONTENT_ALLOW_VALIDATABLE_TEXT} (or,
- * in case of mixed content, {@link #validateElementEnd}, for the
- * last enclosed element). Otherwise, validator context may choose
- * not to call the method as an optimization.
- *
- * @param cbuf Character array that contains text content to validate
- * @param textStart Index of the first character of the content to
- * validate
- * @param textEnd Character following the last character of the
- * content to validate (that is, length of content to validate is
- * textEnd - textStart
).
- * @param lastTextSegment Whether this text content is the last text
- * segment before a close element; true if it is, false if it is not,
- * or no determination can be made. Can be used for optimizing
- * validation -- if this is true, no text needs to be buffered since
- * no more will be sent before the current element closes.
- */
- public abstract void validateText(char[] cbuf, int textStart, int textEnd,
- boolean lastTextSegment)
- throws XMLStreamException;
-
- /**
- * Method called when the validation is completed; either due to the
- * input stream ending, or due to an explicit 'stop validation' request
- * by the application (via context object).
- *
- * @param eod Flag that indicates whether this method was called by the
- * context due to the end of the stream (true); or by an application
- * requesting end of validation (false).
- */
- public abstract void validationCompleted(boolean eod)
- throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////
- // Access to post-validation data (type info)
- ///////////////////////////////////////////////////
- */
-
- /**
- * Method for getting schema-specified type of an attribute, if
- * information is available. If not, validators can return
- * null to explicitly indicate no information was available.
- */
- public abstract String getAttributeType(int index);
-
- /**
- * Method for finding out the index of the attribute that
- * is of type ID; derived from DTD, W4C Schema, or some other validation
- * source. Usually schemas explicitly specifies that at most one
- * attribute can have this type for any element.
- *
- * @return Index of the attribute with type ID, in the current
- * element, if one exists: -1 otherwise
- */
- public abstract int getIdAttrIndex();
-
- /**
- * Method for finding out the index of the attribute (collected using
- * the attribute collector; having DTD/Schema-derived info in same order)
- * that is of type NOTATION. DTD explicitly specifies that at most one
- * attribute can have this type for any element.
- *
- * @return Index of the attribute with type NOTATION, in the current
- * element, if one exists: -1 otherwise
- */
- public abstract int getNotationAttrIndex();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLEventReader2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLEventReader2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLEventReader2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLEventReader2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,65 +0,0 @@
-package org.codehaus.stax2;
-
-import javax.xml.stream.XMLEventReader;
-import javax.xml.stream.XMLStreamException;
-
-/**
- * Extended interface that implements functionality that is missing
- * from {@link XMLEventReader}, based on findings on trying to
- * implement Stax API v1.0.
- */
-public interface XMLEventReader2
- extends XMLEventReader
-{
- /**
- * Method that is similar to {@link #hasNext}, except that it can
- * throw a {@link XMLStreamException}. This is important distinction,
- * since the underlying stream reader is NOT allowed to throw such an
- * exception when its
- * hasNext()
gets called; but the underlying parser
- * may well need to advance the input stream and in doing so may
- * encounter an exception. This exception should be propagated to
- * the caller, as it may signal a problem with the input stream
- * or xml content.
- */
- public boolean hasNextEvent() throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // Configuration
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method similar to {@link javax.xml.stream.XMLInputFactory#isPropertySupported}, used
- * to determine whether a property is supported by the Reader
- * instance. This means that this method may return false
- * for some properties that the input factory does support: specifically,
- * it should only return true if the value is mutable on per-instance
- * basis. False means that either the property is not recognized, or
- * is not mutable via reader instance.
- *
- * @since 3.0
- */
- public boolean isPropertySupported(String name);
-
- /**
- * Method that can be used to set per-reader properties; a subset of
- * properties one can set via matching
- * {@link org.codehaus.stax2.XMLInputFactory2}
- * instance. Exactly which methods are mutable is implementation
- * specific.
- *
- * @param name Name of the property to set
- * @param value Value to set property to.
- *
- * @return True, if the specified property was succesfully
- * set to specified value; false if its value was not changed
- *
- * @throws InvalidArgumentException if the property is not supported
- * (or recognized) by the stream reader implementation
- *
- * @since 3.0
- */
- public boolean setProperty(String name, Object value);
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLInputFactory2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLInputFactory2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLInputFactory2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLInputFactory2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,367 +0,0 @@
-package org.codehaus.stax2;
-
-import java.io.File;
-import java.net.URL;
-
-import javax.xml.stream.XMLInputFactory;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamReader;
-
-/**
- * Extension of {@link XMLInputFactory} that adds some convenience factory
- * methods as new standard properties that conforming stream
- * reader factory and instance implementations need to
- * recognize, and preferably support. There are also some profile-based
- * configuration methods which allow implementations to set proper goal-based
- * values for custom properties.
- *
- * NOTE: although actual values for the property names are
- * visible, implementations should try to use the symbolic constants
- * defined here instead, to avoid typos.
- *
- * @version 3.0 01/21/2007
- * @author Tatu Saloranta (tatu.saloranta@iki.fi)
- */
-public abstract class XMLInputFactory2
- extends XMLInputFactory
- implements XMLStreamProperties
-{
- /*
- ///////////////////////////////////////////////////////////
- // We share some options with other factories
- ///////////////////////////////////////////////////////////
- */
-
- //public final static String XSP_IMPLEMENTATION_NAME
- //public final static String XSP_IMPLEMENTATION_VERSION
- //public final static String XSP_SUPPORTS_XML11
- //public final static String XSP_NAMESPACE_AWARE
- //public final static String XSP_PROBLEM_REPORTER
-
- //public final static String XSP_SUPPORT_XMLID
-
- /*
- ///////////////////////////////////////////////////////////
- // Additional standard configuration properties
- ///////////////////////////////////////////////////////////
- */
-
- // // // Parsing settings
-
- /**
- * Whether reader will generate 'ignorable white space' events during
- * prolog and epilog (before and after the main XML root element);
- * if true, will generate those events; if false,
- * will just ignore white space in these parts of the parsed document.
- *
- * Turning this feature off may give slight performance improvement, - * although usually effect should be negligible. This option is usually - * only turned on when round-trip output should be as similar to input - * as possible. - *
- * Default value for this setting is implementation dependant. - */ - public final static String P_REPORT_PROLOG_WHITESPACE = "org.codehaus.stax2.reportPrologWhitespace"; - - /** - * Whether cursor-based reader will ever generate CDATA events; if true, - * CDATA events may be generated for non-coalesced CDATA sections. If - * false, all CDATA sections are reported as CHARACTERS types. It may - * still be possible for event methods to distinguish between underlying - * type, but event type code will be reported as CHARACTERS. - *
- * State of property does not have any effect on performance. - *
- * Default value for this setting is implementation dependant. - */ - public final static String P_REPORT_CDATA = "http://java.sun.com/xml/stream/properties/report-cdata-event"; - - /** - * Whether stream readers are allowed to do lazy parsing, meaning - * to parse minimal part of the event when - * {@link XMLStreamReader#next} is called, and only parse the rest - * as needed (or skip remainder of no extra information is needed). - * Alternative to lazy parsing is called "eager parsing", and is - * what most xml parsers use by default. - *
- * Enabling lazy parsing can improve performance for tasks where - * number of textual events are skipped. The downside is that - * not all well-formedness problems are reported when - * {@link XMLStreamReader#next} is called, but only when the - * rest of event are read or skipped. - *
- * Default value for this setting is implementation dependant. - */ - public final static String P_LAZY_PARSING = "com.ctc.wstx.lazyParsing"; - - // // // Optimization settings - - /** - * Whether name symbols (element, attribute, entity and notation names, - * namespace prefixes) - * stream reader returns are guaranteed to have been String.intern()ed. - * Interning generally makes access faster (both internal and externally), - * and saves memory, but can add some overhead for processing. - * It may also be problematic for large symbol spaces; especially - * if xml content has unbounded value space for names. - *
- * Default value for this setting is implementation dependant. - * Additionally implementations may have use different default for - * different types of stream readers. - */ - public final static String P_INTERN_NAMES = "org.codehaus.stax2.internNames"; - - /** - * Whether namespace URIs - * stream reader returns are guaranteed to have been String.intern()ed. - * Interning can make access by fully-qualified name faster as well - * as save memory, but it can also add - * some overhead when encountering a namespace URI for the first - * time. - *
- * Default value for this setting is implementation dependant. - */ - public final static String P_INTERN_NS_URIS = "org.codehaus.stax2.internNsUris"; - - /** - * Property that determines whether stream reader instances are required - * to try to keep track of the parser Location in the input documents. - *
- * When turned on, the stream reader should try to do its best to keep
- * track of the locations, to be able to properly create
- * XMLEvent
objects with accurate Location information.
- * Similarly, implementation should keep track of the location for
- * error reporting purposes, and include this information within
- * XMLStreamException
instances.
- *
- * When turned off, implementations are allowed to optimize things,
- * and only keep/pass partial Location information, or even none at
- * all. Implementations are still encouraged to keep some location
- * information for error reporting purposes, even if they do not
- * maintain accurate
- * XMLEvent
locations, or exact byte/character offsets.
- *
- * Default value for this setting is true. - */ - public final static String P_PRESERVE_LOCATION = "org.codehaus.stax2.preserveLocation"; - - // // // Input source settings - - /** - * Whether stream reader is to close the underlying input source (input - * stream, reader) when stream reader is closed. Basic StAX2 - * specification mandates this feature to be set to false by default - * (for sources that are passed by the application). - *
- * Note: if set to true, readers are also allowed (but not required) to - * close the underlying input source when they do not need it any more, - * for example when encountering EOF, or when throwing an unrecoverable - * parsing exception - */ - public final static String P_AUTO_CLOSE_INPUT = "org.codehaus.stax2.closeInputSource"; - - // // // Validation settings - - /** - * Property used to specify the source for DTD external subset to use - * instead of DTD specified by the XML document itself (if any). - */ - public final static String P_DTD_OVERRIDE = "org.codehaus.stax2.propDtdOverride"; - - /* - /////////////////////////////////////////////////////////// - // Life-cycle - /////////////////////////////////////////////////////////// - */ - - protected XMLInputFactory2() { - super(); - } - - - // // // New event reader creation methods: - - /** - * Factory method that allows for parsing a document accessible via - * specified URL. Note that URL may refer to all normal URL accessible - * resources, from files to web- and ftp-accessible documents. - */ - public abstract XMLEventReader2 createXMLEventReader(URL src) - throws XMLStreamException; - - /** - * Convenience factory method that allows for parsing a document - * stored in the specified file. - */ - public abstract XMLEventReader2 createXMLEventReader(File f) - throws XMLStreamException; - - // // // New stream reader creation methods: - - /** - * Factory method that allows for parsing a document accessible via - * specified URL. Note that URL may refer to all normal URL accessible - * resources, from files to web- and ftp-accessible documents. - */ - public abstract XMLStreamReader2 createXMLStreamReader(URL src) - throws XMLStreamException; - - /** - * Convenience factory method that allows for parsing a document - * stored in the specified file. - */ - public abstract XMLStreamReader2 createXMLStreamReader(File f) - throws XMLStreamException; - - /* - /////////////////////////////////////////////////////////// - // Configuring using profiles - /////////////////////////////////////////////////////////// - */ - - /** - * Method to call to make Reader created conform as closely to XML - * standard as possible, doing all checks and transformations mandated - * by the XML specification (linefeed conversions, attr value - * normalizations). - *
- * Regarding the default StAX property settings, - * implementations are suggested to do following: - *
SUPPORT_DTD
property.
- * IS_NAMESPACE_AWARE
- * IS_REPLACING_ENTITY_REFERENCES
- * IS_SUPPORTING_EXTERNAL_ENTITIES
- * - * In addition, implementations should set implementation-dependant - * settings appropriately, to be as strict as possible with regards - * to XML specification mandated checks and transformations. - */ - public abstract void configureForXmlConformance(); - - /** - * Method to call to make Reader created be as "convenient" to use - * as possible; ie try to avoid having to deal with some of things - * like segmented text chunks. This may incur some slight performance - * penalties, but should not affect XML conformance. - *
- * Regarding the default StAX property settings, - * implementations are suggested to do following: - *
IS_COALESCING
(text coalescing)
- * IS_REPLACING_ENTITY_REFERENCES
- * P_REPORT_PROLOG_WHITESPACE
(StAX2); so
- * that the application need not skip possible SPACE
- * (and COMMENT
, PROCESSING_INSTRUCTION
)
- * events.
- * P_REPORT_ALL_TEXT_AS_CHARACTERS
(StAX2)
- * P_PRESERVE_LOCATION
(StAX2)
- * - * In addition, implementations should set implementation-dependant - * settings appropriately as well. - */ - public abstract void configureForConvenience(); - - /** - * Method to call to make the Reader created be as fast as possible reading - * documents, especially for long-running processes where caching is - * likely to help. This means reducing amount of information collected - * (ignorable white space in prolog/epilog, accurate Location information - * for Event API), and possibly even including simplifying handling - * of XML-specified transformations (skip attribute value and text - * linefeed normalization). - * Potential downsides are somewhat increased memory usage - * (for full-sized input buffers), and reduced XML conformance (will not - * do some of transformations). - *
- * Regarding the default StAX property settings, - * implementations are suggested to do following: - *
IS_COALESCING
(text coalescing)
- * P_PRESERVE_LOCATION
(StAX2)
- * P_REPORT_PROLOG_WHITESPACE
(StAX2)
- * P_INTERN_NAMES
(StAX2)
- * P_INTERN_NS_URIS
(StAX2)
- * - * In addition, implementations should set implementation-dependant - * settings appropriately as well. - */ - public abstract void configureForSpeed(); - - /** - * Method to call to minimize the memory usage of the stream/event reader; - * both regarding Objects created, and the temporary memory usage during - * parsing. - * This generally incurs some performance penalties, due to using - * smaller input buffers. - *
- * Regarding the default StAX property settings, - * implementations are suggested to do following: - *
IS_COALECING
(text coalescing, can force
- * longer internal result buffers to be used)
- * P_PRESERVE_LOCATION
(StAX) to reduce
- * temporary memory usage.
- * - * In addition, implementations should set implementation-dependant - * settings appropriately so that the memory usage is minimized. - */ - public abstract void configureForLowMemUsage(); - - /** - * Method to call to make Reader try to preserve as much of input - * formatting as possible, so that round-tripping would be as lossless - * as possible. This means that the matching writer should be able to - * reproduce output as closely matching input format as possible - * (most implementations won't be able to provide 100% vis-a-vis; - * white space between attributes is generally lost, as well as use - * of character entities). - *
- * Regarding the default StAX property settings, - * implementations are suggested to do following: - *
IS_COALESCING
(to prevent CDATA and Text
- * segments from getting combined)
- * IS_REPLACING_ENTITY_REFERENCES
to allow for
- * preserving explicitly declared general entity references (that is,
- * there is no way to preserve character entities, or pre-defined
- * entities like 'gt', 'lt', 'amp', 'apos' and 'quot').
- * P_REPORT_ALL_TEXT_AS_CHARACTERS
(StAX2)
- * (so that CDATA sections are not reported as 'normal' text)
- * P_REPORT_PROLOG_WHITESPACE
(StAX2)
- * - * In addition, implementations should set implementation-dependant - * settings appropriately as well. - */ - public abstract void configureForRoundTripping(); -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLOutputFactory2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLOutputFactory2.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLOutputFactory2.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLOutputFactory2.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,202 +0,0 @@ -package org.codehaus.stax2; - -import java.io.Writer; - -import javax.xml.stream.XMLEventWriter; -import javax.xml.stream.XMLOutputFactory; -import javax.xml.stream.XMLStreamException; -import javax.xml.stream.XMLStreamWriter; // only for javadoc - -import org.codehaus.stax2.io.EscapingWriterFactory; - -/** - * Extension of {@link javax.xml.stream.XMLInputFactory} to add - * missing functionality. - *
- * Also contains extended standard properties that conforming stream
- * writer factory and instance implementations should at least
- * recognize, and preferably support.
- *
- * NOTE: although actual values for the property names are
- * visible, implementations should try to use the symbolic constants
- * defined here instead, to avoid typos.
- *
- * Notes about properties that output factories should support: - *
- * Default value for implementations should be 'true'; both values should - * be recognized, and 'false' must be honored. However, 'true' value - * is only a suggestion, and need not be implemented (since there is - * the explicit 'writeEmptyElement()' method). - */ - public final static String P_AUTOMATIC_EMPTY_ELEMENTS = "org.codehaus.stax2.automaticEmptyElements"; - - // // // Output stream/writer settings - - /** - * Whether stream writer is to close the underlying output - * destination (output stream, reader) when stream writer is closed. - * Basic StAX2 specification mandates this feature to be set to - * false by default - * (for destinations that are passed by the application and for which - * it has access to). - *
- * Note: if set to true, writers are also allowed (but not required) to - * close the underlying destination when they do not need it any more, - * for example when throwing an (unrecoverable) exception - */ - public final static String P_AUTO_CLOSE_OUTPUT = "org.codehaus.stax2.autoCloseOutput"; - - // // Namespace options: - - /** - * Prefix to use for automatically created namespace prefixes, when - * namespace support is enabled, the writer is in "repairing" - * mode, and a new prefix name is needed. The value is a String, - * and needs to be a valid namespace prefix in itself, as defined - * by the namespace specification. Will be prepended by a trailing - * part (often a sequence number), in order to make it unique to - * be usable as a temporary non-colliding prefix. - */ - public final static String P_AUTOMATIC_NS_PREFIX = "org.codehaus.stax2.automaticNsPrefix"; - - // // Text/attribute value escaping options: - - /** - * Property that can be set if a custom output escaping for textual - * content is needed. - * The value set needs to be of type {@link EscapingWriterFactory}. - * When set, the factory will be used to create a per-writer - * instance used to escape all textual content written, both - * via explicit {@link XMLStreamWriter#writeCharacters} methods, - * and via copy methods ({@link XMLStreamWriter2#copyEventFromReader}). - */ - public final static String P_TEXT_ESCAPER = "org.codehaus.stax2.textEscaper"; - - /** - * Property that can be set if a custom output escaping for attribute - * value content is needed. - * The value set needs to be of type {@link EscapingWriterFactory}. - * When set, the factory will be used to create a per-writer - * instance used to escape all attribute values written, both - * via explicit {@link XMLStreamWriter#writeAttribute} methods, - * and via copy methods ({@link XMLStreamWriter2#copyEventFromReader}). - */ - public final static String P_ATTR_VALUE_ESCAPER = "org.codehaus.stax2.attrValueEscaper"; - - /* - /////////////////////////////////////////////////////////// - // Life-cycle - /////////////////////////////////////////////////////////// - */ - - protected XMLOutputFactory2() { - super(); - } - - - public abstract XMLEventWriter createXMLEventWriter(Writer w, String encoding) - throws XMLStreamException; - - public abstract XMLEventWriter createXMLEventWriter(XMLStreamWriter sw) - throws XMLStreamException; - - public abstract XMLStreamWriter2 createXMLStreamWriter(Writer w, String encoding) - throws XMLStreamException; - - /* - /////////////////////////////////////////////////////////// - // Configuring using profiles - /////////////////////////////////////////////////////////// - */ - - /** - * Method call to make writer be as strict with output as possible, - * ie maximize validation it does to try to catch any well-formedness - * or validity problems. - *
- * This configuration does add some overhead to output process, since - * it enables content checks that are overhead. - *
- * None of currently defined standard properties should be affected, - * but implementations are likely to enable/disable custom - * properties related to validation. - */ - public abstract void configureForXmlConformance(); - - /** - * Method call to make writer be as robust as possible, that is, to - * make it both check AND fix problems if it can. - *
- * Like {@link #configureForXmlConformance}, this configuration adds - * some overhead to output process. - *
- * None of currently defined standard properties should be affected, - * but implementations are likely to enable/disable custom - * properties related to validation. - */ - public abstract void configureForRobustness(); - - /** - * Method call to make writer optimize its operation for speed. This - * generally disably additional checks (if any) writer does, and is - * likely to disable many things that {@link #configureForXmlConformance} - * (and {@link #configureForRobustness}) enables. - *
- * None of currently defined standard properties should be affected. - */ - public abstract void configureForSpeed(); -} diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLReporter2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLReporter2.java --- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLReporter2.java 2011-01-28 05:39:41.000000000 +0000 +++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLReporter2.java 1970-01-01 00:00:00.000000000 +0000 @@ -1,38 +0,0 @@ -package org.codehaus.stax2; - -import javax.xml.stream.XMLReporter; -import javax.xml.stream.XMLStreamException; - -import org.codehaus.stax2.validation.XMLValidationProblem; - -/** - * Extension of {@link XMLReporter} to allow for better access to - * information about the actual problem. - *
- * Note on type of problems reported: although type is - * {@link XMLValidationProblem}, it is not strictly related to (optional) - * validation process. That is, non-fatal problems related to well-formedness - * (mostly in areas of DTD definition, or in some cases problems that would - * be fatal normally but have been suppressed by the calling app) will - * also be reported through this interface if registered. - *
- * Stax2 implementations are encouraged to always try to call the improved
- * report
method, and only call the base interface version if
- * registered report is not of type {@link XMLReporter2}.
- *
- * @since 3.0
- */
-public interface XMLReporter2
- extends XMLReporter
-{
- // From base interface:
- //public void report(String message, String errorType, Object relatedInformation, Location location)
-
- /**
- * Reporting method called with reference to object that defines
- * exact problem being encountered. Implementor is free to
- * quietly handle the problem, or to throw an exception
- * to cause abnormal termination of xml processing.
- */
- public void report(XMLValidationProblem problem) throws XMLStreamException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLStreamLocation2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLStreamLocation2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLStreamLocation2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLStreamLocation2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,54 +0,0 @@
-package org.codehaus.stax2;
-
-import javax.xml.stream.Location;
-
-/**
- * Extension of {@link Location} that adds accessor to retrieve nested
- * location information.
- */
-public interface XMLStreamLocation2
- extends Location
-{
- /**
- * "Dummy" Location implementation and instance that can be return
- * instead of null, when no location information is available.
- */
- public final static XMLStreamLocation2 NOT_AVAILABLE = new XMLStreamLocation2() {
- public XMLStreamLocation2 getContext() {
- return null;
- }
-
- public int getCharacterOffset() {
- return -1;
- }
-
- public int getColumnNumber() {
- return -1;
- }
-
- public int getLineNumber() {
- return -1;
- }
-
- public String getPublicId() {
- return null;
- }
-
- public String getSystemId() {
- return null;
- }
- };
-
- /**
- * Method that can be used to traverse nested locations, like ones
- * created when expanding entities (especially external entities).
- * If so, single location object only contains information about
- * specific offsets and ids, and a link to its context. Outermost
- * location will return null to indicate there is no more information
- * to retrieve.
- *
- * @return Location in the context (parent input source), if any;
- * null for locations in the outermost known context
- */
- public XMLStreamLocation2 getContext();
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLStreamProperties.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLStreamProperties.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLStreamProperties.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLStreamProperties.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,121 +0,0 @@
-package org.codehaus.stax2;
-
-/**
- * This interface defines configuration properties shared by multiple
- * kinds of factories (input, output, validation) or instances produces
- * (readers, writers, validators).
- *
- * Some of the properties here are same as ones earlier defined in
- * {@link javax.xml.stream.XMLInputFactory} and
- * {@link javax.xml.stream.XMLOutputFactory}, and are redeclared here
- * to emphasize the fact they are usable with broader context (esp.
- * properties that use to be only used with input factories but can
- * now be used with output or validation factories).
- */
-public interface XMLStreamProperties
-{
- // // // Information about implementation
-
- /**
- * This read-only property returns name of the implementation. It
- * can be used to determine implementation-specific feature sets,
- * in case other methods (calling isPropertySupported
)
- * does not work adequately.
- */
- public final static String XSP_IMPLEMENTATION_NAME = "org.codehaus.stax2.implName";
-
- /**
- * This read-only property returns the version of the implementation,
- * and is to be used with implementation name
- * ({@link #XSP_IMPLEMENTATION_NAME}) property.
- */
- public final static String XSP_IMPLEMENTATION_VERSION = "org.codehaus.stax2.implVersion";
-
- /**
- * This read-only property indicates whether the implementation
- * supports xml 1.1 content; Boolean.TRUE indicates it does,
- * Boolean.FALSE that it does not.
- */
- public final static String XSP_SUPPORTS_XML11 = "org.codehaus.stax2.supportsXml11";
-
- // // // Re-declared properties from XMLInputFactory
-
- /**
- * Property that can be set to indicate that namespace information is
- * to be handled in conformance to the xml namespaces specifiation; or
- * false to indicate no namespace handling should be done.
- */
- public final static String XSP_NAMESPACE_AWARE = "javax.xml.stream.isNamespaceAware";
-
- /**
- * Property that can be set to specify a problem handler which will get
- * notified of non-fatal problem (validation errors in non-validating mode,
- * warnings). Its value has to be of type
- * {@link javax.xml.stream.XMLReporter}
- */
- public final static String XSP_PROBLEM_REPORTER = "javax.xml.stream.reporter";
-
- // // // Generic XML feature support:
-
- /**
- * Read/write property that can be set to change the level of xml:id
- * specification support, if the implementation implements xml:id
- * specification. Value to set should be one of
- * XSP_V_XMLID_xxx
constants (like
- * {@link #XSP_V_XMLID_TYPING}).
- *
- * Default value is implementation-specific, but recommended default
- * value is
- * The main reason for specifying this value (as opposed to the full
- * enabling) is that there is some overhead associated with
- * validation (especially uniqueness constraints checking, which means
- * that all values of xml:id attributes in the input document have to
- * be kept in memory), whereas typing is a low overhead operation.
- */
- public final static String XSP_V_XMLID_TYPING = "xmlidTyping";
-
- /**
- * Property value to use with property
- * {@link #XSP_SUPPORT_XMLID}.
- * Value indicates that both the attribute type assignment
- * portion and the validation portion of xml:id should be supported.
- * This validation is independent of the actual schema (DTD, RNG,
- * W3C Schema) validation, in the sense that even if no such validation
- * is enabled, xml:id value validation will still be done if this
- * property value is used. Conversely, if schema-based validation
- * is used, both xml:id and schema validation may be done (although
- * schema validator instances may choose to ignore validity checks
- * if they know that full xml:id support is enabled).
- */
- public final static String XSP_V_XMLID_FULL = "xmlidFull";
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLStreamReader2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLStreamReader2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLStreamReader2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLStreamReader2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,322 +0,0 @@
-/* Stax2 extension for basic Stax API (JSR-173).
- *
- * Copyright (c) 2005- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.codehaus.stax2;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import javax.xml.namespace.NamespaceContext;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamReader;
-
-import org.codehaus.stax2.typed.TypedXMLStreamReader;
-import org.codehaus.stax2.validation.Validatable;
-
-/**
- * Extended interface that implements functionality that is necessary
- * to properly build event API on top of {@link XMLStreamReader}.
- * It also adds limited number of methods that are important for
- * efficient pass-through processing (such as one needed when routing
- * SOAP-messages).
- *
- * The features supported via {@link #setFeature} are:
- *
- * Since version 3.0, stream writer will also implement "Typed Access API"
- * on output side.
- *
- * @version 3.0.1 06-Nov-2008
- * @author Tatu Saloranta (tatu.saloranta@iki.fi)
- */
-public interface XMLStreamReader2
- extends TypedXMLStreamReader,
- Validatable
-{
- /**
- * Feature used to specify the source for DTD external subset to use
- * instead of DTD specified by the XML document itself (if any).
- *
- * @deprecated Use {@link XMLInputFactory2#P_DTD_OVERRIDE} instead.
- */
- public final static String FEATURE_DTD_OVERRIDE = XMLInputFactory2.P_DTD_OVERRIDE;
-
- /*
- ///////////////////////////////////////////////////////////
- // Configuration
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method similar to {@link javax.xml.stream.XMLInputFactory#isPropertySupported}, used
- * to determine whether a property is supported by the Reader
- * instance. This means that this method may return false
- * for some properties that the input factory does support: specifically,
- * it should only return true if the value is mutable on per-instance
- * basis. False means that either the property is not recognized, or
- * is not mutable via reader instance.
- */
- public boolean isPropertySupported(String name);
-
- /**
- * Method that can be used to set per-reader properties; a subset of
- * properties one can set via matching
- * {@link org.codehaus.stax2.XMLInputFactory2}
- * instance. Exactly which methods are mutable is implementation
- * specific.
- *
- * @param name Name of the property to set
- * @param value Value to set property to.
- *
- * @return True, if the specified property was succesfully
- * set to specified value; false if its value was not changed
- *
- * @throws InvalidArgumentException if the property is not supported
- * (or recognized) by the stream reader implementation
- */
- public boolean setProperty(String name, Object value);
-
- /**
- * Method that can be used to get per-reader values; both generic
- * ones (names for which are defined as constants in this class),
- * and implementation dependant ones.
- *
- * Note: although some feature names are shared with
- * {@link #setFeature}, not all are: some features are read-only,
- * some write-only
- *
- * @deprecated Should use {@link #getProperty} instead
- *
- * @param name Name of the feature of which value to get
- *
- * @return Value of the feature (possibly null), if supported; null
- * otherwise
- */
- public Object getFeature(String name);
-
- /**
- * Method that can be used to set per-reader features such as configuration
- * settings; both generic
- * ones (names for which are defined as constants in this class),
- * and implementation dependant ones.
- *
- * Note: although some feature names are shared with
- * {@link #getFeature}, not all are: some features are read-only,
- * some write-only
- *
- * @deprecated Should use {@link #setProperty} instead
- *
- * @param name Name of the feature to set
- * @param value Value to set feature to.
- */
- public void setFeature(String name, Object value);
-
- /*
- ///////////////////////////////////////////////////////////
- // Additional event traversing
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method that will skip all the contents of the element that the
- * stream currently points to. Current event when calling the method
- * has to be START_ELEMENT (or otherwise {@link IllegalStateException}
- * is thrown); after the call the stream will point to the matching
- * END_ELEMENT event, having skipped zero or more intervening events
- * for the contents.
- */
- public void skipElement() throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // Additional DTD access
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method that can be called to get information about DOCTYPE declaration
- * that the reader is currently pointing to, if the reader has parsed
- * it. Implementations can also choose to return null to indicate they
- * do not provide extra information; but they should not throw any
- * exceptions beyond normal parsing exceptions.
- *
- * @return Information object for accessing further DOCTYPE information,
- * iff the reader currently points to DTD event, AND is operating
- * in mode that parses such information (DTD-aware at least, and
- * usually also validating)
- */
- public DTDInfo getDTDInfo() throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // Additional attribute accessors
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method that can be called to get additional information about
- * attributes related to the current start element, as well as
- * related DTD-based information if available. Note that the
- * reader has to currently point to START_ELEMENT; if not,
- * a {@link IllegalStateException} will be thrown.
- */
- public AttributeInfo getAttributeInfo() throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // Extended location information access
- ///////////////////////////////////////////////////////////
- */
-
- public LocationInfo getLocationInfo();
-
- /*
- ///////////////////////////////////////////////////////////
- // Pass-through text accessors
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method similar to {@link #getText()}, except
- * that it just uses provided Writer to write all textual content,
- * and that it works for wider range of event types.
- * For further optimization, it may also be allowed to do true
- * pass-through, thus possibly avoiding one temporary copy of the
- * data. Finally, note that this method is also guaranteed NOT
- * to return fragments, even when coalescing is not enabled and
- * a parser is otherwised allowed to return partial segments: this
- * requirement is due to there being little benefit in returning
- * such short chunks when streaming. Coalescing property is still
- * honored normally.
- *
- * Method can only be called on states CDATA, CHARACTERS, COMMENT,
- * DTD, ENTITY_REFERENCE, SPACE and PROCESSING_INSTRUCTION; if called
- * when reader is in another state,
- * {@link IllegalStateException} will be thrown. Content written
- * for elements is same as with {@link #getText()}.
- *
- * @param w Writer to use for writing textual contents
- * @param preserveContents If true, reader has to preserve contents
- * so that further calls to
- * Note: method may need to read more data to know if the element
- * is an empty one, and as such may throw an i/o or parsing exception
- * (as {@link XMLStreamException}); however, it won't throw exceptions
- * for non-START_ELEMENT event types.
- *
- * @return True, if current event is START_ELEMENT
- * and is based on a parsed empty element; otherwise false
- */
- public boolean isEmptyElement() throws XMLStreamException;
-
- /**
- * Method that returns the number of open elements in the stack; 0 when
- * the reader is in prolog/epilog, 1 inside root element (including
- * when pointing at the root element itself) and so on.
- * Depth is same for matching start/end elements, as well as for the
- * all children of an element.
- *
- * @return Number of open elements currently in the reader's stack,
- * including current START_ELEMENT or END_ELEMENT (if pointing to one).
- */
- public int getDepth();
-
- /**
- * This method returns a namespace context object that contains
- * information identical to that returned by
- * {@link javax.xml.stream.XMLStreamReader#getNamespaceContext()},
- * but one that is
- * not transient. That is, one that will remain valid and unchanged
- * after its creation. This allows the namespace context to be used
- * independent of its source documents life cycle. One possible use
- * case is to use this namespace context for 'initializing' writers
- * (especially ones that use repairing mode) with optimal/preferred name
- * space bindings.
- *
- * @return Non-transient namespace context as explained above.
- */
- public NamespaceContext getNonTransientNamespaceContext();
-
- /**
- * This method returns "prefix-qualified" name of the current
- * element. In general, this means character-by-character exact
- * name of the element in XML content, and may be useful in informational
- * purposes, as well as when interacting with packages and APIs that
- * use such names (such as what SAX may use as qnames).
- *
- * Note: implementations are encouraged to provide an implementation
- * that would be more efficient than calling
- * Since version 3.0, stream writer will also implement "Typed Access API"
- * on output side.
- *
- * @version 3.0.1 06-Nov-2008
- * @author Tatu Saloranta (tatu.saloranta@iki.fi)
- */
-public interface XMLStreamWriter2
- extends TypedXMLStreamWriter,
- Validatable
-{
- /*
- ///////////////////////////////////////////////////////////
- // Configuration
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method similar to {@link javax.xml.stream.XMLOutputFactory#isPropertySupported}, used
- * to determine whether a property is supported by the Writer
- * instance. This means that this method may return false
- * for some properties that the output factory does support: specifically,
- * it should only return true if the value is mutable on per-instance
- * basis. False means that either the property is not recognized, or
- * is not mutable via writer instance.
- */
- public boolean isPropertySupported(String name);
-
- /**
- * Method that can be used to set per-writer properties; a subset of
- * properties one can set via matching
- * {@link org.codehaus.stax2.XMLOutputFactory2}
- * instance. Exactly which methods are mutable is implementation
- * specific.
- *
- * @param name Name of the property to set
- * @param value Value to set property to.
- *
- * @return True, if the specified property was succesfully
- * set to specified value; false if its value was not changed
- *
- * @throws InvalidArgumentException if the property is not supported
- * (or recognized) by the stream writer implementation
- */
- public boolean setProperty(String name, Object value);
-
- /*
- ///////////////////////////////////////////////////////////
- // Other accessors, mutators
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method that should return current output location, if the writer
- * keeps track of it; null if it does not.
- */
- public XMLStreamLocation2 getLocation();
-
- /**
- * Method that can be called to get information about encoding that
- * this writer is using (or at least claims is using). That is,
- * it returns name of encoding specified when (in order of priority):
- *
- * This method is useful for things like outputting indentation.
- *
- * @since 3.0
- */
- public void writeSpace(String text)
- throws XMLStreamException;
-
- /**
- * Method that can be called to write whitespace-only content.
- * If so, it is to be written as is (with no escaping), and does
- * not contain non-whitespace characters (writer may validate this,
- * and throw an exception if it does).
- *
- * This method is useful for things like outputting indentation.
- *
- * @since 3.0
- */
- public void writeSpace(char[] text, int offset, int length)
- throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // Pass-through methods
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method that writes specified content as is, without encoding or
- * deciphering it in any way. It will not update state of the writer
- * (except by possibly flushing output of previous writes, like
- * finishing a start element),
- * nor be validated in any way. As such, care must be taken, if this
- * method is used.
- *
- * Method is usually used when encapsulating output from another writer
- * as a sub-tree, or when passing through XML fragments.
- *
- * NOTE: since text to be written may be anything, including markup,
- * it can not be reliably validated. Because of this, validator(s)
- * attached to the writer will NOT be informed about writes.
- */
- public void writeRaw(String text)
- throws XMLStreamException;
-
- /**
- * Method that writes specified content as is, without encoding or
- * deciphering it in any way. It will not update state of the writer
- * (except by possibly flushing output of previous writes, like
- * finishing a start element),
- * nor be validated in any way. As such, care must be taken, if this
- * method is used.
- *
- * Method is usually used when encapsulating output from another writer
- * as a sub-tree, or when passing through XML fragments.
- *
- * NOTE: since text to be written may be anything, including markup,
- * it can not be reliably validated. Because of this, validator(s)
- * attached to the writer will NOT be informed about writes.
- */
- public void writeRaw(String text, int offset, int length)
- throws XMLStreamException;
-
- /**
- * Method that writes specified content as is, without encoding or
- * deciphering it in any way. It will not update state of the writer
- * (except by possibly flushing output of previous writes, like
- * finishing a start element),
- * nor be validated in any way. As such, care must be taken, if this
- * method is used.
- *
- * Method is usually used when encapsulating output from another writer
- * as a sub-tree, or when passing through XML fragments.
- *
- * NOTE: since text to be written may be anything, including markup,
- * it can not be reliably validated. Because of this, validator(s)
- * attached to the writer will NOT be informed about writes.
- */
- public void writeRaw(char[] text, int offset, int length)
- throws XMLStreamException;
-
- /**
- * Method that essentially copies
- * event that the specified reader has just read.
- * This can be both more convenient
- * (no need to worry about details) and more efficient
- * than separately calling access methods of the reader and
- * write methods of the writer, since writer may know more
- * about reader than the application (and may be able to use
- * non-public methods)
- *
- * @param r Reader to use for accessing event to copy
- * @param preserveEventData If true, writer is not allowed to change
- * the state of the reader (so that all the data associated with the
- * current event has to be preserved); if false, writer is allowed
- * to use methods that may cause some data to be discarded. Setting
- * this to false may improve the performance, since it may allow
- * full no-copy streaming of data, especially textual contents.
- */
- public void copyEventFromReader(XMLStreamReader2 r, boolean preserveEventData)
- throws XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // Output handling
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method similar to
- * {@link javax.xml.stream.XMLStreamWriter#close()},
- * except that this method also does close the underlying output
- * destination (stream) if it has not yet been closed.
- * It is specifically necessary to call this method if the parsing ends
- * in an exception to ensure that the output destination does get
- * properly closed, even if the stream writer would otherwise close
- * it (as is the case for destinations it manages where calling
- * application has no access)
- */
- public void closeCompletely()
- throws XMLStreamException;
-}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/AttributeInfo.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/AttributeInfo.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/AttributeInfo.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/AttributeInfo.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,56 @@
+package org.codehaus.stax2;
+
+/**
+ * Interface that specifies additional access methods for accessing
+ * combined attribute information reader has, after parsing individual
+ * and combining that with DTD information (if any available; depends on
+ * parser's mode).
+ *
+ * Note: instances of AttributeInfo are only guaranteed to persist as long
+ * as the (stream) reader points to the START_ELEMENT event, during
+ * which attribute information was parsed. It is possible that some
+ * implementations persist instances afterwards, but it's equally
+ * possible that instances get reused, and as such information
+ * may change.
+ */
+public interface AttributeInfo
+{
+ // // // Generic methods; some duplication from main stream reader
+
+ /**
+ * @return Number of all attributes accessible (including ones created
+ * from the default values, if any) using this Object.
+ */
+ public int getAttributeCount();
+
+ // // // Methods for finding index of specific attributes
+
+ /**
+ * @return Index of the specified attribute, if the current element
+ * has such an attribute (explicit, or one created via default
+ * value expansion); -1 if not.
+ */
+ public int findAttributeIndex(String nsURI, String localName);
+
+ /**
+ * Returns the index of the id attribute (attribute with any name,
+ * type ID from DTD) of current (start) element, if any. Note that
+ * DTD only allows at most one such attribute per element.
+ *
+ * @return Index of the ID attribute of current element,
+ * if the current element has such an
+ * attribute defined; -1 if not.
+ */
+ public int getIdAttributeIndex();
+
+ /**
+ * Returns the index of the notation attribute (attribute with any name,
+ * type NOTATION from DTD) of current (start) element, if any. Note that
+ * DTD only allows at most one such attribute per element.
+ *
+ * @return Index of the NOTATION attribute of current element,
+ * if the current element has such an
+ * attribute defined; -1 if not.
+ */
+ public int getNotationAttributeIndex();
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/DTDInfo.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/DTDInfo.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/DTDInfo.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/DTDInfo.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,59 @@
+package org.codehaus.stax2;
+
+import org.codehaus.stax2.validation.DTDValidationSchema;
+
+/**
+ * Interface that specifies additional access functionality to parsed DTD
+ * information (if any); these methods are encapsulated on a separate
+ * interface to keep the main reader interface from exploding.
+ *
+ * Note: instances of DTDInfo are not guaranteed to persist when the reader
+ * that returned it is asked to provide the next event. Some implementations
+ * may let it persist, others might not.
+ */
+public interface DTDInfo
+{
+ // // // Stax2, v1.0
+
+ /**
+ * @return If current event is DTD, DTD support is enabled,
+ * and reader supports DTD processing, returns an internal
+ * Object implementation uses for storing/processing DTD;
+ * otherwise returns null.
+ */
+ public Object getProcessedDTD();
+
+ /**
+ * @return If current event is DTD, returns the full root name
+ * (including prefix, if any); otherwise returns null
+ */
+ public String getDTDRootName();
+
+ /**
+ * @return If current event is DTD, and has a system id, returns the
+ * system id; otherwise returns null.
+ */
+ public String getDTDSystemId();
+
+ /**
+ * @return If current event is DTD, and has a public id, returns the
+ * public id; otherwise returns null.
+ */
+ public String getDTDPublicId();
+
+ /**
+ * @return If current event is DTD, and has an internal subset,
+ * returns the internal subset; otherwise returns null.
+ */
+ public String getDTDInternalSubset();
+
+
+ // // // Stax2, v2.0
+
+ /**
+ * Method similar to {@link #getProcessedDTD}, but type-safe. Will
+ * return the DTD schema instance that was read, if we are in mode
+ * where it does get read (at least dtd-aware).
+ */
+ public DTDValidationSchema getProcessedDTDSchema();
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/evt/DTD2.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/evt/DTD2.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/evt/DTD2.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/evt/DTD2.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,20 @@
+package org.codehaus.stax2.evt;
+
+import javax.xml.stream.events.DTD;
+
+/**
+ * Interface that extends basic {@link DTD} with methods that are
+ * necessary to completely reproduce actual DOCTYPE declaration
+ * constructs in xml documents.
+ */
+public interface DTD2
+ extends DTD
+{
+ public String getRootName();
+
+ public String getSystemId();
+
+ public String getPublicId();
+
+ public String getInternalSubset();
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/evt/NotationDeclaration2.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/evt/NotationDeclaration2.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/evt/NotationDeclaration2.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/evt/NotationDeclaration2.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,14 @@
+package org.codehaus.stax2.evt;
+
+import javax.xml.stream.events.NotationDeclaration;
+
+/**
+ * Interface that extends basic {@link NotationDeclaration} to add
+ * support for handling Base URI needed to resolve Notation references.
+ * This
+ */
+public interface NotationDeclaration2
+ extends NotationDeclaration
+{
+ public String getBaseURI();
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/evt/XMLEvent2.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/evt/XMLEvent2.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/evt/XMLEvent2.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/evt/XMLEvent2.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,21 @@
+package org.codehaus.stax2.evt;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.XMLEvent;
+
+import org.codehaus.stax2.XMLStreamWriter2;
+
+/**
+ * Interface that extends basic {@link XMLEvent2} with method(s)
+ * that are missing from it; specifically linkage that allows using
+ * a stream/event writer for outputting.
+ *
+ * NOTE: Unfortunately there is no way to cleanly retrofit this interface
+ * to actual implementation classes, so some casting is necessary to
+ * make use of new features.
+ */
+public interface XMLEvent2
+ extends XMLEvent
+{
+ public void writeUsing(XMLStreamWriter2 w) throws XMLStreamException;
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/evt/XMLEventFactory2.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/evt/XMLEventFactory2.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/evt/XMLEventFactory2.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/evt/XMLEventFactory2.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,23 @@
+package org.codehaus.stax2.evt;
+
+import javax.xml.stream.XMLEventFactory;
+
+/**
+ * Interface that adds missing (but required) methods to
+ * {@link XMLEventFactory}; especially ones for creating actual
+ * well-behaving DOCTYPE events.
+ */
+public abstract class XMLEventFactory2
+ extends XMLEventFactory
+{
+ protected XMLEventFactory2() {
+ super();
+ }
+
+ public abstract DTD2 createDTD(String rootName, String sysId, String pubId,
+ String intSubset);
+
+ public abstract DTD2 createDTD(String rootName, String sysId, String pubId,
+ String intSubset, Object processedDTD);
+}
+
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/EscapingWriterFactory.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/EscapingWriterFactory.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/EscapingWriterFactory.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/EscapingWriterFactory.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,57 @@
+package org.codehaus.stax2.io;
+
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+
+/**
+ * Interface that defines API for the factories stream writers use for
+ * creating "escaping writers". These factories are used when defining
+ * custom escaping of text (as well as possibly used by the
+ * implementations for default escaping too). Escaping in this context
+ * refers to the process of replacing individual text/attribute content
+ * character with pre-defined and character entities, as per XML
+ * specification (2.4, Appendix D).
+ *
+ * Typical escaping writers replace characters like '<' and '&',
+ * as well as some additional characters depending on context.
+ * Custom implementations may choose to escape additional characters,
+ * for example to make it easier to manually view or edit resulting
+ * serialized XML document.
+ *
+ * Note about implementing escaping writers: writers need to obey normal
+ * Writer semantics, and specifically they should pass calls to
+ *
+ * Note that no copy is made of the passed-in array, and that further
+ * there are direct access methods. Thus, although callers are not
+ * to modify contents of returned array, this can not be guaranteed;
+ * and as such if this would be a problem (security problem for example),
+ * caller has to make a copy of the array and pass that copy to the
+ * constructor.
+ */
+public class Stax2ByteArraySource
+ extends Stax2BlockSource
+{
+ private final static String DEFAULT_ENCODING = "UTF-8";
+
+ final byte[] mBuffer;
+ final int mStart;
+ final int mLength;
+
+ public Stax2ByteArraySource(byte[] buf, int start, int len)
+ {
+ mBuffer = buf;
+ mStart = start;
+ mLength = len;
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Implementation of the Public API
+ /////////////////////////////////////////
+ */
+
+ /**
+ * Note: if encoding is not explicitly defined, UTF-8 is assumed.
+ */
+ @Override
+ public Reader constructReader() throws IOException
+ {
+ String enc = getEncoding();
+ InputStream in = constructInputStream();
+ if (enc == null || enc.length() == 0) {
+ // 11-Nov-2008, TSa: Used to rely on platform default encoding, which
+ // doesn't make sense. XML assumes UTF-8 anyway.
+ enc = DEFAULT_ENCODING;
+ }
+ return new InputStreamReader(in, enc);
+ }
+
+ @Override
+ public InputStream constructInputStream() throws IOException
+ {
+ return new ByteArrayInputStream(mBuffer, mStart, mLength);
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Additional API for this source
+ /////////////////////////////////////////
+ */
+
+ public byte[] getBuffer() {
+ return mBuffer;
+ }
+
+ public int getBufferStart() {
+ return mStart;
+ }
+
+ public int getBufferLength() {
+ return mLength;
+ }
+
+ public int getBufferEnd() {
+ int end = mStart;
+ if (mLength > 0) {
+ end += mLength;
+ }
+ return end;
+ }
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2CharArraySource.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2CharArraySource.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2CharArraySource.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2CharArraySource.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,68 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+
+/**
+ * Simple implementation of {@link Stax2BlockSource} that encapsulates
+ * an char array.
+ *
+ * Note that no copy is made of the passed-in array, and that further
+ * there are direct access methods. Thus, although callers are not
+ * to modify contents of returned array, this can not be guaranteed;
+ * and as such if this would be a problem (security problem for example),
+ * caller has to make a copy of the array and pass that copy to the
+ * constructor.
+ */
+public class Stax2CharArraySource
+ extends Stax2BlockSource
+{
+ final char[] mBuffer;
+ final int mStart;
+ final int mLength;
+
+ public Stax2CharArraySource(char[] buf, int start, int len)
+ {
+ mBuffer = buf;
+ mStart = start;
+ mLength = len;
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Implementation of the Public API
+ /////////////////////////////////////////
+ */
+
+ @Override
+ public Reader constructReader() throws IOException
+ {
+ return new CharArrayReader(mBuffer, mStart, mLength);
+ }
+
+ @Override
+ public InputStream constructInputStream() throws IOException
+ {
+ /* No obvious/easy way; if caller really wants an InputStream, it
+ * can get a Reader, add an encoders, and so on.
+ */
+ return null;
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Additional API for this source
+ /////////////////////////////////////////
+ */
+
+ public char[] getBuffer() {
+ return mBuffer;
+ }
+
+ public int getBufferStart() {
+ return mStart;
+ }
+
+ public int getBufferLength() {
+ return mLength;
+ }
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2FileResult.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2FileResult.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2FileResult.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2FileResult.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,50 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+
+/**
+ * Simple implementation of {@link Stax2ReferentialResult}, which refers
+ * to the specific file.
+ */
+public class Stax2FileResult
+ extends Stax2ReferentialResult
+{
+ final File mFile;
+
+ public Stax2FileResult(File f) {
+ mFile = f;
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Implementation of the Public API
+ /////////////////////////////////////////
+ */
+
+ @Override
+ public Writer constructWriter() throws IOException
+ {
+ String enc = getEncoding();
+ if (enc != null && enc.length() > 0) {
+ return new OutputStreamWriter(constructOutputStream(), enc);
+ }
+ // Sub-optimal; really shouldn't use the platform default encoding
+ return new FileWriter(mFile);
+ }
+
+ @Override
+ public OutputStream constructOutputStream() throws IOException
+ {
+ return new FileOutputStream(mFile);
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Additional API for this Result
+ /////////////////////////////////////////
+ */
+
+ public File getFile() {
+ return mFile;
+ }
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2FileSource.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2FileSource.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2FileSource.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2FileSource.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,74 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+import java.net.URL;
+
+/**
+ * Simple implementation of {@link Stax2ReferentialSource}, which refers
+ * to the specific file.
+ */
+public class Stax2FileSource
+ extends Stax2ReferentialSource
+{
+ final File _file;
+
+ public Stax2FileSource(File f) {
+ _file = f;
+ }
+
+ /*
+ /**********************************************************************
+ /* Implementation of the Public API
+ /**********************************************************************
+ */
+
+ /**
+ * @return URL that refers to the reference resource, for the purposes
+ * of resolving a relative reference from content read from the
+ * resource.
+ */
+ @Override
+ public URL getReference()
+ {
+ /* !!! 13-May-2006, TSa: For Woodstox 4.0, consider converting
+ * first to URI, then to URL, to ensure that characters in the
+ * filename are properly quoted
+ */
+ try {
+ return _file.toURL();
+ } catch (java.net.MalformedURLException e) {
+ /* Hmmh. Signature doesn't allow IOException to be thrown. So,
+ * let's use something close enough; this should not occur
+ * often in practice.
+ */
+ throw new IllegalArgumentException("(was "+e.getClass()+") Could not convert File '"+_file.getPath()+"' to URL: "+e);
+ }
+ }
+
+ @Override
+ public Reader constructReader() throws IOException
+ {
+ String enc = getEncoding();
+ if (enc != null && enc.length() > 0) {
+ return new InputStreamReader(constructInputStream(), enc);
+ }
+ // Sub-optimal; really shouldn't use the platform default encoding
+ return new FileReader(_file);
+ }
+
+ @Override
+ public InputStream constructInputStream() throws IOException
+ {
+ return new FileInputStream(_file);
+ }
+
+ /*
+ /**********************************************************************
+ /* Additional API for this source
+ /**********************************************************************
+ */
+
+ public File getFile() {
+ return _file;
+ }
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2ReferentialResult.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2ReferentialResult.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2ReferentialResult.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2ReferentialResult.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,28 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+
+/**
+ * This is the mid-level abstract base class for {@link Stax2Result}s
+ * that refer to a resource in such a way, that an efficient
+ * {@link OutputStream} or {@link Writer} can be constructed.
+ *
+ * @see Stax2FileResult
+ */
+public abstract class Stax2ReferentialResult
+ extends Stax2Result
+{
+ protected Stax2ReferentialResult() { }
+
+ /*
+ /////////////////////////////////////////
+ // Public API
+ /////////////////////////////////////////
+ */
+
+ @Override
+ public abstract Writer constructWriter() throws IOException;
+
+ @Override
+ public abstract OutputStream constructOutputStream() throws IOException;
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2ReferentialSource.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2ReferentialSource.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2ReferentialSource.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2ReferentialSource.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,57 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+import java.net.URL;
+
+/**
+ * This is the mid-level abstract base class for {@link Stax2Source}s
+ * that refer to a resource in such a way, that an efficient
+ * {@link InputStream} or {@link Reader} can be constructed.
+ * Additionally, referenced sources also provide the base URI that allows
+ * for resolving relative references from within content read from
+ * such resources. Typical examples of references are
+ * {@link java.net.URL} and {@link java.io.File}: both for which
+ * a default implementations exist in this package
+ *
+ * @see Stax2FileSource
+ * @see Stax2URLSource
+ */
+public abstract class Stax2ReferentialSource
+ extends Stax2Source
+{
+ protected Stax2ReferentialSource() { }
+
+ /*
+ /////////////////////////////////////////
+ // Public API, simple accessors/mutators
+ /////////////////////////////////////////
+ */
+
+ @Override
+ public abstract URL getReference();
+
+ @Override
+ public abstract Reader constructReader() throws IOException;
+
+ @Override
+ public abstract InputStream constructInputStream() throws IOException;
+
+ /*
+ /////////////////////////////////////////
+ // Overrides
+ /////////////////////////////////////////
+ */
+
+ /**
+ * Since we can determine a system id from the base URL
+ */
+ @Override
+ public String getSystemId()
+ {
+ String sysId = super.getSystemId();
+ if (sysId == null) {
+ sysId = getReference().toExternalForm();
+ }
+ return sysId;
+ }
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2Result.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2Result.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2Result.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2Result.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,99 @@
+package org.codehaus.stax2.io;
+
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.Writer;
+
+import javax.xml.transform.Result;
+
+/**
+ * This is the base class for additional output results (implementations
+ * of {@link javax.xml.transform.Result}) that Stax2
+ * {@link org.codehaus.stax2.XMLInputFactory2} implementations should support.
+ *
+ * Note about usage by the parser factory implementations: the expectation
+ * is that at least one of methods {@link #constructWriter} and
+ * {@link #constructOutputStream} will succeed, but not necessarily both.
+ * This generally depends on type of resource being represented: for example,
+ * if the source is a StringBuffer, it is most naturally
+ * represent via {@link Writer}. For File-backed results, on the other hand,
+ * an {@link OutputStream} is the most natural access method.
+ *
+ * Other things to note about using result {@link Writer}s and
+ * {@link OutputStream}s:
+ *
+ * Note about usage by the parser factory implementations: the expectation
+ * is that at least one of methods {@link #constructReader} and
+ * {@link #constructInputStream} will succeed, but not necessarily both.
+ * This generally depends on type of resource being represented: for example,
+ * if the source is a String or character array, it is most naturally
+ * represent via {@link Reader}. For a byte array, on the other hand,
+ * an {@link InputStream} is the most natural access method.
+ *
+ * Other things to note about using result {@link Reader}s and
+ * {@link InputStream}s:
+ *
+ * Note: instances of LocationInfo are only guaranteed to persist as long
+ * as the (stream) reader points to the current element (whatever it is).
+ * After next call to
+ * Note: this value MAY be the same as the one returned by
+ * {@link #getStartingCharOffset}, but usually only for single-byte
+ * character streams (Ascii, ISO-Latin).
+ *
+ * @return Byte offset (== number of bytes reader so far) within the
+ * underlying stream, if the stream and stream reader are able to
+ * provide this (separate from the character offset, for variable-byte
+ * encodings); -1 if not.
+ */
+ public long getStartingByteOffset();
+
+ /**
+ * Method that can be used to get exact character offset (number of chars
+ * read from the stream right before getting to this location) in the
+ * stream that is pointed to by this reader, right before the start
+ * of the current event.
+ *
+ * Note: this value MAY be the same as the one returned by
+ * {@link #getStartingByteOffset}; this is the case for single-byte
+ * character streams (Ascii, ISO-Latin), as well as for streams for
+ * which byte offset information is not available (Readers, Strings).
+ *
+ * @return Character offset (== number of bytes reader so far) within the
+ * underlying stream, if the stream and stream reader are able to
+ * provide this (separate from byte offset, for variable-byte
+ * encodings); -1 if not.
+ */
+ public long getStartingCharOffset();
+
+ /**
+ * Method that can be used to get exact byte offset (number of bytes
+ * read from the stream right before getting to this location) in the
+ * stream that is pointed to by this reader, right after the end
+ * of the current event.
+ *
+ * Note: this value MAY be the same as the one returned by
+ * {@link #getEndingCharOffset}, but usually only for single-byte
+ * character streams (Ascii, ISO-Latin).
+ *
+ * Note: for lazy-loading implementations, calling this method may
+ * require the underlying stream to be advanced and contents parsed;
+ * this is why it is possible that an exception be thrown.
+ *
+ * @return Byte offset (== number of bytes reader so far) within the
+ * underlying stream, if the stream and stream reader are able to
+ * provide this (separate from the character offset, for variable-byte
+ * encodings); -1 if not.
+ */
+ public long getEndingByteOffset()
+ throws XMLStreamException;
+
+ /**
+ * Method that can be used to get exact character offset (number of chars
+ * read from the stream right before getting to this location) in the
+ * stream that is pointed to by this reader, right after the end
+ * of the current event.
+ *
+ * Note: this value MAY be the same as the one returned by
+ * {@link #getEndingByteOffset}; this is the case for single-byte
+ * character streams (Ascii, ISO-Latin), as well as for streams for
+ * which byte offset information is not available (Readers, Strings).
+ *
+ * Note: for lazy-loading implementations, calling this method may
+ * require the underlying stream to be advanced and contents parsed;
+ * this is why it is possible that an exception be thrown.
+ *
+ * @return Character offset (== number of bytes reader so far) within the
+ * underlying stream, if the stream and stream reader are able to
+ * provide this (separate from byte offset, for variable-byte
+ * encodings); -1 if not.
+ */
+ public long getEndingCharOffset()
+ throws XMLStreamException;
+
+ /*
+ /////////////////////////////////////////////////////
+ // Object-oriented location access methods
+ /////////////////////////////////////////////////////
+ */
+
+ // // // Existing method from XMLStreamReader:
+
+ public Location getLocation();
+
+ // // // New methods:
+
+ /**
+ * An optional method that either returns the location object that points the
+ * starting position of the current event, or null if implementation
+ * does not keep track of it (some may return only end location; and
+ * some no location at all).
+ *
+ * Note: since it is assumed that the start location must either have
+ * been collected by now, or is not accessible (i.e. implementation
+ * [always] returns null), no exception is allowed to be throws, as
+ * no parsing should ever need to be done (unlike with
+ * {@link #getEndLocation}).
+ *
+ * @return Location of the first character of the current event in
+ * the input source (which will also be the starting location
+ * of the following event, if any, or EOF if not), or null (if
+ * implementation does not track locations).
+ */
+ public XMLStreamLocation2 getStartLocation();
+
+ /**
+ * A method that returns the current location of the stream reader
+ * at the input source. This is somewhere between the start
+ * and end locations (inclusive), depending on how parser does it
+ * parsing (for non-lazy implementations it's always the end location;
+ * for others something else).
+ *
+ * Since this location information should always be accessible, no
+ * further parsing is to be done, and no exceptions can be thrown.
+ *
+ * @return Location of the next character reader will parse in the
+ * input source.
+ */
+ public XMLStreamLocation2 getCurrentLocation();
+
+ /**
+ * An optional method that either returns the location object that points the
+ * ending position of the current event, or null if implementation
+ * does not keep track of it (some may return only start location; and
+ * some no location at all).
+ *
+ * Note: since some implementations may not yet know the end location
+ * (esp. ones that do lazy loading), this call may require further
+ * parsing. As a result, this method may throw a parsing or I/O
+ * errors.
+ *
+ * @return Location right after the end
+ * of the current event (which will also be the start location of
+ * the next event, if any, or of EOF otherwise).
+ *
+ * @throws XMLStreamException If the stream reader had to advance to
+ * the end of the event (to find the location), it may encounter a
+ * parsing (or I/O) error; if so, that gets thrown
+ */
+ public XMLStreamLocation2 getEndLocation()
+ throws XMLStreamException;
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/osgi/Stax2InputFactoryProvider.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/osgi/Stax2InputFactoryProvider.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/osgi/Stax2InputFactoryProvider.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/osgi/Stax2InputFactoryProvider.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,53 @@
+package org.codehaus.stax2.osgi;
+
+import org.codehaus.stax2.XMLInputFactory2;
+import org.codehaus.stax2.XMLStreamProperties;
+
+/**
+ * Simple interface to be used for registering objects that
+ * can construct {@link XMLInputFactory2} instances with OSGi framework.
+ * The added indirection (provider constructing factory) is needed because
+ * of impedance between OSGi service objects (which are essentially
+ * singletons) and Stax/Stax2 factories which are not.
+ *
+ * Note: implementations of provider should NOT use introspection
+ * via {@link javax.xml.stream.XMLInputFactory#newInstance} as it will
+ * not work with OSGi. Instead, providers should directly construct
+ * instances of concrete factory they represent. That is, there will
+ * be one provider implementation per concrete Stax/Stax2 implementation
+ */
+public interface Stax2InputFactoryProvider
+{
+ /*
+ ///////////////////////////////////////////////////////////////
+ // Service property names to use with the provider
+ ///////////////////////////////////////////////////////////////
+ */
+
+ /**
+ * Service property that defines name of Stax2 implementation that
+ * this provider represents.
+ */
+ public final static String OSGI_SVC_PROP_IMPL_NAME = XMLStreamProperties.XSP_IMPLEMENTATION_NAME;
+
+ /**
+ * Service property that defines version of Stax2 implementation that
+ * this provider represents.
+ */
+ public final static String OSGI_SVC_PROP_IMPL_VERSION = XMLStreamProperties.XSP_IMPLEMENTATION_VERSION;
+
+ /*
+ ///////////////////////////////////////////////////////////////
+ // Public provider API
+ ///////////////////////////////////////////////////////////////
+ */
+
+ /**
+ * Method called to create a new {@link XMLInputFactory2} instance.
+ *
+ * @return Input factory configured to implementation-specific
+ * default settings (some of which are mandated by Stax and Stax2
+ * specifications)
+ */
+ public XMLInputFactory2 createInputFactory();
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/osgi/Stax2OutputFactoryProvider.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/osgi/Stax2OutputFactoryProvider.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/osgi/Stax2OutputFactoryProvider.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/osgi/Stax2OutputFactoryProvider.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,53 @@
+package org.codehaus.stax2.osgi;
+
+import org.codehaus.stax2.XMLOutputFactory2;
+import org.codehaus.stax2.XMLStreamProperties;
+
+/**
+ * Simple interface to be used for registering objects that
+ * can construct {@link XMLOutputFactory2} instances with OSGi framework.
+ * The added indirection (provider constructing factory) is needed because
+ * of impedance between OSGi service objects (which are essentially
+ * singletons) and Stax/Stax2 factories which are not.
+ *
+ * Note: implementations of provider should NOT use introspection
+ * via {@link javax.xml.stream.XMLOutputFactory#newInstance} as it will
+ * not work with OSGi. Instead, providers should directly construct
+ * instances of concrete factory they represent. That is, there will
+ * be one provider implementation per concrete Stax/Stax2 implementation
+ */
+public interface Stax2OutputFactoryProvider
+{
+ /*
+ ///////////////////////////////////////////////////////////////
+ // Service property names to use with the provider
+ ///////////////////////////////////////////////////////////////
+ */
+
+ /**
+ * Service property that defines name of Stax2 implementation that
+ * this provider represents.
+ */
+ public final static String OSGI_SVC_PROP_IMPL_NAME = XMLStreamProperties.XSP_IMPLEMENTATION_NAME;
+
+ /**
+ * Service property that defines version of Stax2 implementation that
+ * this provider represents.
+ */
+ public final static String OSGI_SVC_PROP_IMPL_VERSION = XMLStreamProperties.XSP_IMPLEMENTATION_VERSION;
+
+ /*
+ ///////////////////////////////////////////////////////////////
+ // Public provider API
+ ///////////////////////////////////////////////////////////////
+ */
+
+ /**
+ * Method called to create a new {@link XMLOutputFactory2} instance.
+ *
+ * @return Output factory configured to implementation-specific
+ * default settings (some of which are mandated by Stax and Stax2
+ * specifications)
+ */
+ public XMLOutputFactory2 createOutputFactory();
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/osgi/Stax2ValidationSchemaFactoryProvider.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/osgi/Stax2ValidationSchemaFactoryProvider.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/osgi/Stax2ValidationSchemaFactoryProvider.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/osgi/Stax2ValidationSchemaFactoryProvider.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,77 @@
+package org.codehaus.stax2.osgi;
+
+import org.codehaus.stax2.XMLStreamProperties;
+import org.codehaus.stax2.validation.XMLValidationSchemaFactory;
+
+/**
+ * Simple interface to be used for registering objects that
+ * can construct {@link XMLValidationSchemaFactory} instances with OSGi framework.
+ * The added indirection (provider constructing factory) is needed because
+ * of impedance between OSGi service objects (which are essentially
+ * singletons) and Stax/Stax2 factories which are not.
+ *
+ * Note: implementations of provider should NOT use introspection
+ * via {@link XMLValidationSchemaFactory#newInstance} as it will
+ * not work with OSGi. Instead, providers should directly construct
+ * instances of concrete factory they represent. That is, there will
+ * be one provider implementation per concrete Stax/Stax2 implementation
+ */
+public interface Stax2ValidationSchemaFactoryProvider
+{
+ /*
+ ///////////////////////////////////////////////////////////////
+ // Service property names to use with the provider
+ ///////////////////////////////////////////////////////////////
+ */
+
+ /**
+ * Service property that defines name of Stax2 implementation that
+ * this provider represents.
+ */
+ public final static String OSGI_SVC_PROP_IMPL_NAME = XMLStreamProperties.XSP_IMPLEMENTATION_NAME;
+
+ /**
+ * Service property that defines version of Stax2 implementation that
+ * this provider represents.
+ */
+ public final static String OSGI_SVC_PROP_IMPL_VERSION = XMLStreamProperties.XSP_IMPLEMENTATION_VERSION;
+
+ /**
+ * Service property that defines type of Schemas (one of constants from
+ * {@link org.codehaus.stax2.validation.XMLValidationSchema},
+ * such as {@link org.codehaus.stax2.validation.XMLValidationSchema#SCHEMA_ID_DTD})
+ * that the schema factory this provider handles supports. Can be used
+ * to locate proper provider for the schema type.
+ */
+ public final static String OSGI_SVC_PROP_SCHEMA_TYPE = "org.codehaus.stax2.validation.schemaType";
+
+ /*
+ ///////////////////////////////////////////////////////////////
+ // Public provider API
+ ///////////////////////////////////////////////////////////////
+ */
+
+ /**
+ * Method that can be used to determine which schema type this
+ * provider (or, rather, factory instances of which provider
+ * constructs) supports.
+ *
+ * @return Id of schema type that the factory instantiated by this
+ * provider will support.
+ */
+ public String getSchemaType();
+
+ /**
+ * Method called to create a new {@link XMLValidationSchemaFactory}
+ * instance. Each schema factory supports a single schema type;
+ * so caller has to ensure that the factory it is using supports
+ * schema it needs to instantiate. This can be done either by using
+ * service properties, or by inspecting provider instances for
+ * schema type they support (see {@link #getSchemaType}).
+ *
+ * @return ValidationSchema factory configured to implementation-specific
+ * default settings, if type is supported by this provider; null
+ * if not.
+ */
+ public XMLValidationSchemaFactory createValidationSchemaFactory();
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/ri/dom/DOMWrappingReader.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/ri/dom/DOMWrappingReader.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/ri/dom/DOMWrappingReader.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/ri/dom/DOMWrappingReader.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,2311 @@
+/* Stax2 API extension for Streaming API for XML processing (StAX).
+ *
+ * Copyright (c) 2006- Tatu Saloranta, tatu.saloranta@iki.fi
+ *
+ * Licensed under the License specified in the file LICENSE which is
+ * included with the source code.
+ * You may not use this file except in compliance with the License.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.codehaus.stax2.ri.dom;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+import javax.xml.transform.dom.DOMSource;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.stream.*;
+
+import org.w3c.dom.*;
+
+import org.codehaus.stax2.AttributeInfo;
+import org.codehaus.stax2.DTDInfo;
+import org.codehaus.stax2.LocationInfo;
+import org.codehaus.stax2.XMLStreamLocation2;
+import org.codehaus.stax2.XMLStreamReader2;
+import org.codehaus.stax2.ri.EmptyIterator;
+import org.codehaus.stax2.ri.EmptyNamespaceContext;
+import org.codehaus.stax2.ri.SingletonIterator;
+import org.codehaus.stax2.ri.Stax2Util;
+import org.codehaus.stax2.ri.typed.StringBase64Decoder;
+import org.codehaus.stax2.ri.typed.ValueDecoderFactory;
+import org.codehaus.stax2.typed.Base64Variant;
+import org.codehaus.stax2.typed.Base64Variants;
+import org.codehaus.stax2.typed.TypedArrayDecoder;
+import org.codehaus.stax2.typed.TypedValueDecoder;
+import org.codehaus.stax2.typed.TypedXMLStreamException;
+import org.codehaus.stax2.validation.DTDValidationSchema;
+import org.codehaus.stax2.validation.ValidationProblemHandler;
+import org.codehaus.stax2.validation.XMLValidationSchema;
+import org.codehaus.stax2.validation.XMLValidator;
+
+/**
+ * This is an adapter class that presents a DOM document as if it was
+ * a regular {@link XMLStreamReader}. This is mostly useful for
+ * inter-operability purposes, and should only be used when the
+ * input has to come as a DOM object and the original xml content
+ * is not available as a stream.
+ *
+ * Note that the implementation is only to be used for use with
+ *
+ * Some notes regarding missing/incomplete functionality:
+ *
+ */
+ protected List
+ * Note: as per StAX 1.0 specs, this method does NOT close the underlying
+ * input reader. That is, unless the new StAX2 property
+ * {@link org.codehaus.stax2.XMLInputFactory2#P_AUTO_CLOSE_INPUT} is
+ * set to true.
+ */
+ public void close() throws XMLStreamException
+ {
+ // Since DOM tree has no real input source, nothing to do
+ }
+
+ /*
+ /**********************************************************************
+ /* NamespaceContext
+ /**********************************************************************
+ */
+
+ public String getNamespaceURI(String prefix)
+ {
+ /* !!! 26-Apr-2006, TSa: Alas, these methods are DOM Level 3,
+ * i.e. require JDK 1.5 or higher
+ */
+ /*
+ if (prefix.length() == 0) { // def NS
+ return _currNode.lookupNamespaceURI(null);
+ }
+ return _currNode.lookupNamespaceURI(prefix);
+ */
+
+ Node n = _currNode;
+ boolean defaultNs = (prefix == null) || (prefix.length() == 0);
+
+ while (n != null) {
+ NamedNodeMap attrs = n.getAttributes();
+ if (attrs != null){
+ for (int i = 0, len = attrs.getLength(); i < len; ++i) {
+ Node attr = attrs.item(i);
+ String thisPrefix = attr.getPrefix();
+ if (thisPrefix == null || thisPrefix.length() == 0) { // nope
+ if (defaultNs && "xmlns".equals(attr.getLocalName())) {
+ return attr.getNodeValue();
+ }
+ } else if (!defaultNs && "xmlns".equals(thisPrefix)) {
+ if (prefix.equals(attr.getLocalName())) {
+ return attr.getNodeValue();
+ }
+ }
+ }
+ }
+ n = n.getParentNode();
+ }
+ return null;
+ }
+
+ public String getPrefix(String namespaceURI)
+ {
+ /* !!! 26-Apr-2006, TSa: Alas, these methods are DOM Level 3,
+ * i.e. require JDK 1.5 or higher
+ */
+ /*
+ String prefix = _currNode.lookupPrefix(namespaceURI);
+ if (prefix == null) { // maybe default NS?
+ String defURI = _currNode.lookupNamespaceURI(null);
+ if (defURI != null && defURI.equals(namespaceURI)) {
+ return "";
+ }
+ }
+ return prefix;
+ */
+
+ Node n = _currNode;
+ if (namespaceURI == null) { // not sure if this is even legal but...
+ namespaceURI = "";
+ }
+
+ while (n != null) {
+ NamedNodeMap attrs = n.getAttributes();
+ for (int i = 0, len = attrs.getLength(); i < len; ++i) {
+ Node attr = attrs.item(i);
+ String thisPrefix = attr.getPrefix();
+ if (thisPrefix == null || thisPrefix.length() == 0) {
+ if ("xmlns".equals(attr.getLocalName()) && namespaceURI.equals(attr.getNodeValue())) {
+ return "";
+ }
+ } else if ("xmlns".equals(thisPrefix)) {
+ if (namespaceURI.equals(attr.getNodeValue())) {
+ return attr.getLocalName();
+ }
+ }
+ }
+ n = n.getParentNode();
+ }
+ return null;
+ }
+
+ public Iterator
+ * TODO: try to optimize to allow completely streaming pass-through:
+ * currently will still read all data in memory buffers before
+ * outputting
+ *
+ * @param w Writer to use for writing textual contents
+ * @param preserveContents If true, reader has to preserve contents
+ * so that further calls to
+ * Note that the implementation is only to be used with
+ *
+ * One more implementation note: much code is identical to one
+ * used by {@link org.codehaus.stax2.ri.Stax2WriterAdapter}.
+ * Alas it is hard to reuse it without cut'n pasting.
+ *
+ * @author Tatu Saloranta
+ *
+ * @since 3.0
+ */
+public abstract class DOMWrappingWriter
+ implements XMLStreamWriter2
+{
+ // // Constants to use as defaults for "writeStartDocument"
+
+ final static String DEFAULT_OUTPUT_ENCODING = "UTF-8";
+
+ final static String DEFAULT_XML_VERSION = "1.0";
+
+ /*
+ ////////////////////////////////////////////////////
+ // Configuration
+ ////////////////////////////////////////////////////
+ */
+
+ protected final boolean mNsAware;
+
+ protected final boolean mNsRepairing;
+
+ /**
+ * This member variable is to keep information about encoding
+ * that seems to be used for the document (or fragment) to output,
+ * if known.
+ */
+ protected String mEncoding = null;
+
+ /**
+ * If we are being given info about existing bindings, it'll come
+ * as a NamespaceContext.
+ */
+ protected NamespaceContext mNsContext;
+
+ /*
+ ////////////////////////////////////////////////////
+ // State
+ ////////////////////////////////////////////////////
+ */
+
+ /**
+ * We need a reference to the document hosting nodes to
+ * be able to create new nodes
+ */
+ protected final Document mDocument;
+
+ /*
+ ////////////////////////////////////////////////////
+ // Helper objects
+ ////////////////////////////////////////////////////
+ */
+
+ /**
+ * Encoding of typed values is used the standard encoder
+ * included in RI.
+ */
+ protected SimpleValueEncoder mValueEncoder;
+
+ /*
+ ////////////////////////////////////////////////////
+ // Life-cycle
+ ////////////////////////////////////////////////////
+ */
+
+ protected DOMWrappingWriter(Node treeRoot,
+ boolean nsAware, boolean nsRepairing)
+ throws XMLStreamException
+ {
+ if (treeRoot == null) {
+ throw new IllegalArgumentException("Can not pass null Node for constructing a DOM-based XMLStreamWriter");
+ }
+ mNsAware = nsAware;
+ mNsRepairing = nsRepairing;
+
+ /* Ok; we need a document node; or an element node; or a document
+ * fragment node.
+ */
+ switch (treeRoot.getNodeType()) {
+ case Node.DOCUMENT_NODE: // fine
+ mDocument = (Document) treeRoot;
+
+ /* Should try to find encoding, version and stand-alone
+ * settings... but is there a standard way of doing that?
+ */
+ break;
+
+ case Node.ELEMENT_NODE: // can make sub-tree... ok
+ mDocument = treeRoot.getOwnerDocument();
+ break;
+
+ case Node.DOCUMENT_FRAGMENT_NODE: // as with element...
+ mDocument = treeRoot.getOwnerDocument();
+ // Above types are fine
+ break;
+
+ default: // other Nodes not usable
+ throw new XMLStreamException("Can not create an XMLStreamWriter for a DOM node of type "+treeRoot.getClass());
+ }
+ if (mDocument == null) {
+ throw new XMLStreamException("Can not create an XMLStreamWriter for given node (of type "+treeRoot.getClass()+"): did not have owner document");
+ }
+ }
+
+ /*
+ ////////////////////////////////////////////////////
+ // Partial XMLStreamWriter API (Stax 1.0) impl
+ ////////////////////////////////////////////////////
+ */
+
+ public void close() {
+ // NOP
+ }
+
+ public void flush() {
+ // NOP
+ }
+
+ public abstract NamespaceContext getNamespaceContext();
+ public abstract String getPrefix(String uri);
+ public abstract Object getProperty(String name);
+ public abstract void setDefaultNamespace(String uri);
+
+ public void setNamespaceContext(NamespaceContext context) {
+ mNsContext = context;
+ }
+
+ public abstract void setPrefix(String prefix, String uri)
+ throws XMLStreamException;
+
+ public abstract void writeAttribute(String localName, String value)
+ throws XMLStreamException;
+ public abstract void writeAttribute(String nsURI, String localName, String value)
+ throws XMLStreamException;
+ public abstract void writeAttribute(String prefix, String nsURI, String localName, String value)
+ throws XMLStreamException;
+
+ public void writeCData(String data)
+ throws XMLStreamException
+ {
+ appendLeaf(mDocument.createCDATASection(data));
+ }
+
+ public void writeCharacters(char[] text, int start, int len)
+ throws XMLStreamException
+ {
+ writeCharacters(new String(text, start, len));
+ }
+
+ public void writeCharacters(String text)
+ throws XMLStreamException
+ {
+ appendLeaf(mDocument.createTextNode(text));
+ }
+
+ public void writeComment(String data)
+ throws XMLStreamException
+ {
+ appendLeaf(mDocument.createComment(data));
+ }
+
+ public abstract void writeDefaultNamespace(String nsURI)
+ throws XMLStreamException;
+
+ public void writeDTD(String dtd)
+ throws XMLStreamException
+ {
+ /* Would need to parse contents, not easy to do via DOM
+ * in any case.
+ */
+ reportUnsupported("writeDTD()");
+ }
+
+ public abstract void writeEmptyElement(String localName)
+ throws XMLStreamException;
+ public abstract void writeEmptyElement(String nsURI, String localName)
+ throws XMLStreamException;
+ public abstract void writeEmptyElement(String prefix, String localName, String nsURI)
+ throws XMLStreamException;
+
+ public abstract void writeEndDocument() throws XMLStreamException;
+
+ public void writeEntityRef(String name) throws XMLStreamException
+ {
+ appendLeaf(mDocument.createEntityReference(name));
+ }
+
+ public void writeProcessingInstruction(String target)
+ throws XMLStreamException
+ {
+ writeProcessingInstruction(target, null);
+ }
+
+ public void writeProcessingInstruction(String target, String data)
+ throws XMLStreamException
+ {
+ appendLeaf(mDocument.createProcessingInstruction(target, data));
+ }
+
+ public void writeStartDocument()
+ throws XMLStreamException
+ {
+ /* Note: while these defaults are not very intuitive, they
+ * are what Stax 1.0 specification clearly mandates:
+ */
+ writeStartDocument(DEFAULT_OUTPUT_ENCODING, DEFAULT_XML_VERSION);
+ }
+
+ public void writeStartDocument(String version)
+ throws XMLStreamException
+ {
+ writeStartDocument(null, version);
+ }
+
+ public void writeStartDocument(String encoding, String version)
+ throws XMLStreamException
+ {
+ // Is there anything here we can or should do? No?
+ mEncoding = encoding;
+ }
+
+
+ /*
+ ////////////////////////////////////////////////////
+ // XMLStreamWriter2 API (Stax2 v3.0):
+ // additional accessors
+ ////////////////////////////////////////////////////
+ */
+
+ public XMLStreamLocation2 getLocation() {
+ // !!! TBI
+ return null;
+ }
+
+ public String getEncoding() {
+ return mEncoding;
+ }
+
+ public abstract boolean isPropertySupported(String name);
+ public abstract boolean setProperty(String name, Object value);
+
+ /*
+ ////////////////////////////////////////////////////
+ // XMLStreamWriter2 API (Stax2 v2.0):
+ // extended write methods
+ ////////////////////////////////////////////////////
+ */
+
+ public void writeCData(char[] text, int start, int len)
+ throws XMLStreamException
+ {
+ writeCData(new String(text, start, len));
+ }
+
+ public abstract void writeDTD(String rootName, String systemId, String publicId,
+ String internalSubset)
+ throws XMLStreamException;
+
+ //public void writeDTD(String rootName, String systemId, String publicId, String internalSubset)
+
+ public void writeFullEndElement() throws XMLStreamException
+ {
+ // No difference with DOM
+ writeEndElement();
+ }
+
+ public void writeSpace(char[] text, int start, int len)
+ throws XMLStreamException
+ {
+ writeSpace(new String(text, start, len));
+ }
+
+ public void writeSpace(String text)
+ throws XMLStreamException
+ {
+ /* This won't work all that well, given there's no way to
+ * prevent quoting/escaping. But let's do what we can, since
+ * the alternative (throwing an exception) doesn't seem
+ * especially tempting choice.
+ */
+ writeCharacters(text);
+ }
+
+ public void writeStartDocument(String version, String encoding, boolean standAlone)
+ throws XMLStreamException
+ {
+ writeStartDocument(encoding, version);
+ }
+
+ /*
+ ////////////////////////////////////////////////////
+ // XMLStreamWriter2 API (Stax2 v2.0): validation
+ ////////////////////////////////////////////////////
+ */
+
+ public XMLValidator validateAgainst(XMLValidationSchema schema)
+ throws XMLStreamException
+ {
+ // !!! TBI
+ return null;
+ }
+
+ public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
+ throws XMLStreamException
+ {
+ // !!! TBI
+ return null;
+ }
+
+ public XMLValidator stopValidatingAgainst(XMLValidator validator)
+ throws XMLStreamException
+ {
+ // !!! TBI
+ return null;
+ }
+
+ public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
+ {
+ // !!! TBI
+ return null;
+ }
+
+ /*
+ ///////////////////////////////
+ // Stax2, pass-through methods
+ ///////////////////////////////
+ */
+
+ public void writeRaw(String text)
+ throws XMLStreamException
+ {
+ reportUnsupported("writeRaw()");
+ }
+
+ public void writeRaw(String text, int start, int offset)
+ throws XMLStreamException
+ {
+ reportUnsupported("writeRaw()");
+ }
+
+ public void writeRaw(char[] text, int offset, int length)
+ throws XMLStreamException
+ {
+ reportUnsupported("writeRaw()");
+ }
+
+ public void copyEventFromReader(XMLStreamReader2 r, boolean preserveEventData)
+ throws XMLStreamException
+ {
+ // !!! TBI
+ }
+
+ /*
+ ///////////////////////////////
+ // Stax2, output handling
+ ///////////////////////////////
+ */
+
+ public void closeCompletely()
+ {
+ // NOP
+ }
+
+ /*
+ /////////////////////////////////////////////////
+ // TypedXMLStreamWriter2 implementation
+ // (Typed Access API, Stax v3.0)
+ /////////////////////////////////////////////////
+ */
+
+ // // // Typed element content write methods
+
+ public void writeBoolean(boolean value) throws XMLStreamException
+ {
+ writeCharacters(value ? "true" : "false");
+ }
+
+ public void writeInt(int value) throws XMLStreamException
+ {
+ writeCharacters(String.valueOf(value));
+ }
+
+ public void writeLong(long value) throws XMLStreamException
+ {
+ writeCharacters(String.valueOf(value));
+ }
+
+ public void writeFloat(float value) throws XMLStreamException
+ {
+ writeCharacters(String.valueOf(value));
+ }
+
+ public void writeDouble(double value) throws XMLStreamException
+ {
+ writeCharacters(String.valueOf(value));
+ }
+
+ public void writeInteger(BigInteger value) throws XMLStreamException
+ {
+ writeCharacters(value.toString());
+ }
+
+ public void writeDecimal(BigDecimal value) throws XMLStreamException
+ {
+ writeCharacters(value.toString());
+ }
+
+ public void writeQName(QName name) throws XMLStreamException
+ {
+ writeCharacters(serializeQNameValue(name));
+ }
+
+ public void writeIntArray(int[] value, int from, int length)
+ throws XMLStreamException
+ {
+ /* true -> start with space, to allow for multiple consecutive
+ * to be written
+ */
+ writeCharacters(getValueEncoder().encodeAsString(value, from, length));
+ }
+
+ public void writeLongArray(long[] value, int from, int length)
+ throws XMLStreamException
+ {
+ // true -> start with space, for multiple segments
+ writeCharacters(getValueEncoder().encodeAsString(value, from, length));
+ }
+
+ public void writeFloatArray(float[] value, int from, int length)
+ throws XMLStreamException
+ {
+ // true -> start with space, for multiple segments
+ writeCharacters(getValueEncoder().encodeAsString(value, from, length));
+ }
+
+ public void writeDoubleArray(double[] value, int from, int length)
+ throws XMLStreamException
+ {
+ // true -> start with space, for multiple segments
+ writeCharacters(getValueEncoder().encodeAsString(value, from, length));
+ }
+
+ public void writeBinary(byte[] value, int from, int length)
+ throws XMLStreamException
+ {
+ writeBinary(Base64Variants.getDefaultVariant(), value, from, length);
+ }
+
+ public void writeBinary(Base64Variant v, byte[] value, int from, int length)
+ throws XMLStreamException
+ {
+ writeCharacters(getValueEncoder().encodeAsString(v, value, from, length));
+ }
+
+ // // // Typed attribute value write methods
+
+ public void writeBooleanAttribute(String prefix, String nsURI, String localName, boolean value)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName, value ? "true" : "false");
+ }
+
+ public void writeIntAttribute(String prefix, String nsURI, String localName, int value)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName, String.valueOf(value));
+ }
+
+ public void writeLongAttribute(String prefix, String nsURI, String localName, long value)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName, String.valueOf(value));
+ }
+
+ public void writeFloatAttribute(String prefix, String nsURI, String localName, float value)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName, String.valueOf(value));
+ }
+
+ public void writeDoubleAttribute(String prefix, String nsURI, String localName, double value)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName, String.valueOf(value));
+ }
+
+ public void writeIntegerAttribute(String prefix, String nsURI, String localName, BigInteger value)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName, value.toString());
+ }
+
+ public void writeDecimalAttribute(String prefix, String nsURI, String localName, BigDecimal value)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName, value.toString());
+ }
+
+ public void writeQNameAttribute(String prefix, String nsURI, String localName, QName name)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName, serializeQNameValue(name));
+ }
+
+ public void writeIntArrayAttribute(String prefix, String nsURI, String localName, int[] value)
+ throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName,
+ getValueEncoder().encodeAsString(value, 0, value.length));
+ }
+
+ public void writeLongArrayAttribute(String prefix, String nsURI, String localName, long[] value) throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName,
+ getValueEncoder().encodeAsString(value, 0, value.length));
+ }
+
+ public void writeFloatArrayAttribute(String prefix, String nsURI, String localName, float[] value) throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName,
+ getValueEncoder().encodeAsString(value, 0, value.length));
+ }
+
+ public void writeDoubleArrayAttribute(String prefix, String nsURI, String localName, double[] value) throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName,
+ getValueEncoder().encodeAsString(value, 0, value.length));
+ }
+
+ public void writeBinaryAttribute(String prefix, String nsURI, String localName, byte[] value) throws XMLStreamException
+ {
+ writeBinaryAttribute(Base64Variants.getDefaultVariant(), prefix, nsURI, localName, value);
+ }
+
+ public void writeBinaryAttribute(Base64Variant v, String prefix, String nsURI, String localName, byte[] value) throws XMLStreamException
+ {
+ writeAttribute(prefix, nsURI, localName,
+ getValueEncoder().encodeAsString(v, value, 0, value.length));
+ }
+
+
+ /*
+ ////////////////////////////////////////////////////
+ // Abstract methods for sub-classes to implement
+ ////////////////////////////////////////////////////
+ */
+
+ protected abstract void appendLeaf(Node n)
+ throws IllegalStateException;
+
+ /*
+ ////////////////////////////////////////////////////
+ // Shared package methods
+ ////////////////////////////////////////////////////
+ */
+
+ /**
+ * Method called to serialize given qualified name into valid
+ * String serialization, taking into account existing namespace
+ * bindings.
+ */
+ protected String serializeQNameValue(QName name)
+ throws XMLStreamException
+ {
+ String prefix;
+ // Ok as is? In repairing mode need to ensure it's properly bound
+ if (mNsRepairing) {
+ String uri = name.getNamespaceURI();
+ // First: let's see if a valid binding already exists:
+ NamespaceContext ctxt = getNamespaceContext();
+ prefix = (ctxt == null) ? null : ctxt.getPrefix(uri);
+ if (prefix == null) {
+ // nope: need to (try to) bind
+ String origPrefix = name.getPrefix();
+ if (origPrefix == null || origPrefix.length() == 0) {
+ prefix = "";
+ /* note: could cause a namespace conflict... but
+ * there is nothing we can do with just stax1 stream
+ * writer
+ */
+ writeDefaultNamespace(uri);
+ } else {
+ prefix = origPrefix;
+ writeNamespace(prefix, uri);
+ }
+ }
+ } else { // in non-repairing, good as is
+ prefix = name.getPrefix();
+ }
+ String local = name.getLocalPart();
+ if (prefix == null || prefix.length() == 0) {
+ return local;
+ }
+
+ // Not efficient... but should be ok
+ return prefix + ":" + local;
+ }
+
+ protected SimpleValueEncoder getValueEncoder()
+ {
+ if (mValueEncoder == null) {
+ mValueEncoder = new SimpleValueEncoder();
+ }
+ return mValueEncoder;
+ }
+
+ /*
+ ////////////////////////////////////////////////////
+ // Package methods, basic output problem reporting
+ ////////////////////////////////////////////////////
+ */
+
+ protected static void throwOutputError(String msg)
+ throws XMLStreamException
+ {
+ throw new XMLStreamException(msg);
+ }
+
+ protected static void throwOutputError(String format, Object arg)
+ throws XMLStreamException
+ {
+ String msg = MessageFormat.format(format, new Object[] { arg });
+ throwOutputError(msg);
+ }
+
+ protected void reportUnsupported(String operName)
+ {
+ throw new UnsupportedOperationException(operName+" can not be used with DOM-backed writer");
+ }
+}
+
+
+
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/ri/EmptyIterator.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/ri/EmptyIterator.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/ri/EmptyIterator.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/ri/EmptyIterator.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,32 @@
+package org.codehaus.stax2.ri;
+
+import java.util.Iterator;
+
+/**
+ * Simple implementation of "null iterator", iterator that has nothing to
+ * iterate over.
+ */
+public final class EmptyIterator
+ implements IteratorXSP_V_XMLID_TYPING
for implementations
- * that do support Xml:id specification: those that do not, have to
- * default to XSP_V_XMLID_NONE.
- * For Xml:id-enabled implementations, typing support is the most
- * logical default, since it
- * provides the intuitive behavior of xml:id functionality, as well
- * as reasonable performance (very little overhead in non-validating
- * mode; usual id checking overhead for validating mode).
- */
- public final static String XSP_SUPPORT_XMLID = "org.codehaus.stax2.supportXmlId";
-
- /**
- * Property value to use with property
- * {@link #XSP_SUPPORT_XMLID}.
- * Property value that indicates that no xml:id support should be
- * enabled.
- */
- public final static String XSP_V_XMLID_NONE = "disable";
-
- /**
- * Property value to use with property
- * {@link #XSP_SUPPORT_XMLID}.
- * Value indicates that the attribute type assignment
- * portion of xml:id should be supported (all 'xml:id' attributes
- * that are not explicitly declared should have attribute type of
- * ID), but that no xml:id specific validation is to be done.
- * Due to typing, value normalization should occur.
- * It is still possible that schema (DTD, RNG, W3C Schema) based
- * validation is done, including validation of values of xml:id
- * attributes, but only based on Schema information.
- *
Feature is write-only, since storing it after loading the DTD
- * in question does not have much use.
- *
- *
- *getText
will return
- * proper conntets. If false, reader is allowed to skip creation
- * of such copies: this can improve performance, but it also means
- * that further calls to getText
is not guaranteed to
- * return meaningful data.
- *
- * @return Number of characters written to the reader
- */
- public int getText(Writer w, boolean preserveContents)
- throws IOException, XMLStreamException;
-
- /*
- ///////////////////////////////////////////////////////////
- // Other accessors
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method that can be used to check whether current START_ELEMENT
- * event was created for an empty element (xml short-hand notation
- * where one tag implies start and end, ending with "/>"), or not.
- *getLocalName
- * and getPrefix
separately, but are not required to do
- * so. Nonetheless it is usually at least as efficient (if not more)
- * to call this method as to do it fully in calling code.
- *
- * @return Prefix-qualified name of the current element; essentially
- * 'prefix:localName' if the element has a prefix, or 'localName'
- * if it does not have one (belongs to the default namespace)
- */
- public String getPrefixedName();
-
- /*
- ///////////////////////////////////////////////////////////
- // Input handling
- ///////////////////////////////////////////////////////////
- */
-
- /**
- * Method similar to
- * {@link javax.xml.stream.XMLStreamReader#getNamespaceContext()},
- * except that this method also does close the underlying input
- * source if it has not yet been closed. It is generally preferable
- * to call this method if the parsing ends in an exception;
- * and for some input sources (when passing
- * a {@link java.io.File} or {@link java.net.URL} for factory
- * method) it has to be called as the application does not have
- * access to the actually input source ({@link java.io.InputStream}
- * opened from a {@link java.net.URL} and so on).
- */
- public void closeCompletely()
- throws XMLStreamException;
-}
diff -Nru libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLStreamWriter2.java libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLStreamWriter2.java
--- libstax2-api-java-3.1.1/src/java/org/codehaus/stax2/XMLStreamWriter2.java 2011-01-28 05:39:41.000000000 +0000
+++ libstax2-api-java-4.1/src/java/org/codehaus/stax2/XMLStreamWriter2.java 1970-01-01 00:00:00.000000000 +0000
@@ -1,242 +0,0 @@
-package org.codehaus.stax2;
-
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
-
-import org.codehaus.stax2.typed.TypedXMLStreamWriter;
-import org.codehaus.stax2.validation.Validatable;
-
-/**
- * Extended interface that implements functionality that is necessary
- * to properly build event API on top of {@link XMLStreamWriter},
- * as well as to configure individual instances.
- * It also adds limited number of methods that are important for
- * efficient pass-through processing (such as one needed when routing
- * SOAP-messages).
- *
- *
- */
- public String getEncoding();
-
- /*
- ///////////////////////////////////////////////////////////
- // Write methods base interface is missing
- ///////////////////////////////////////////////////////////
- */
-
- public void writeCData(char[] text, int start, int len)
- throws XMLStreamException;
-
- public void writeDTD(String rootName, String systemId, String publicId,
- String internalSubset)
- throws XMLStreamException;
-
- /**
- * Method similar to {@link #writeEndElement}, but that will always
- * write the full end element, instead of empty element. This only
- * matters for cases where the element itself has no content, and
- * if writer is allowed to write empty elements when it encounters
- * such start/end element write pairs.
- */
- public void writeFullEndElement() throws XMLStreamException;
-
- public void writeStartDocument(String version, String encoding,
- boolean standAlone)
- throws XMLStreamException;
-
- /**
- * Method that can be called to write whitespace-only content.
- * If so, it is to be written as is (with no escaping), and does
- * not contain non-whitespace characters (writer may validate this,
- * and throw an exception if it does).
- *writeStartDocument
method (explicitly
- * or implicity; latter in cases where defaults are imposed
- * by Stax specification)
- * flush()
and close()
to the underlying
+ * Writer.
+ */
+public interface EscapingWriterFactory
+{
+ /**
+ * Method called to create an instance of escaping writer that
+ * will output content using specified writer,
+ * and escaping necessary characters (depending on
+ * both type [attr, element text] and encoding).
+ *
+ * @param w Underlying writer that the encoding writer should
+ * output
+ * @param enc Encoding to use, as specified by the stream writer
+ * (based on information application has passed)
+ */
+ public Writer createEscapingWriterFor(Writer w, String enc)
+ throws UnsupportedEncodingException;
+
+ /**
+ * Method called to create an instance of escaping writer that
+ * will output to the specified stream, using the specified
+ * encoding,
+ * and escaping necessary characters (depending on
+ * both type [attr, element text] and encoding).
+ *
+ * @param out Underlying stream that the encoding writer should
+ * output using
+ * @param enc Encoding to use, as specified by the stream writer
+ * (based on information application has passed)
+ */
+ public Writer createEscapingWriterFor(OutputStream out, String enc)
+ throws UnsupportedEncodingException;
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2BlockResult.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2BlockResult.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2BlockResult.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2BlockResult.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,31 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+
+/**
+ * This is the mid-level abstract base class for {@link Stax2Result}s
+ * that an be used to write to in-memory (low-level) data structures,
+ * such as byte and char arrays, StringBuffers and so forth.
+ * The main reason for using such a result object (instead of constructing
+ * wrapper Readers or InputStreams) is that concrete implementations
+ * usually also allow more direct access to the underlying data, so
+ * that stream reader implementations may be able to do more optimal
+ * access.
+ */
+public abstract class Stax2BlockResult
+ extends Stax2Result
+{
+ protected Stax2BlockResult() { }
+
+ /*
+ /////////////////////////////////////////
+ // Public API, simple accessors/mutators
+ /////////////////////////////////////////
+ */
+
+ @Override
+ public abstract Writer constructWriter() throws IOException;
+
+ @Override
+ public abstract OutputStream constructOutputStream() throws IOException;
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2BlockSource.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2BlockSource.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2BlockSource.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2BlockSource.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,42 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+import java.net.URL;
+
+/**
+ * This is the mid-level abstract base class for {@link Stax2Source}s
+ * that an be used to access fixed-length in-memory data sources, such
+ * as byte and char arrays, Strings, StringBuffers and so forth.
+ * The main reason for using such a source object (instead of constructing
+ * wrapper Readers or InputStreams) is that concrete implementations
+ * usually also allow more direct access to the underlying data, so
+ * that stream reader implementations may be able to do more optimal
+ * access.
+ */
+public abstract class Stax2BlockSource
+ extends Stax2Source
+{
+ protected Stax2BlockSource() { }
+
+ /*
+ /////////////////////////////////////////
+ // Public API, simple accessors/mutators
+ /////////////////////////////////////////
+ */
+
+ /**
+ * Usually there is no way to refer to the underlying data source,
+ * since they are in-memory data structures. Because of this, the
+ * base implementation just returns null.
+ */
+ @Override
+ public URL getReference() {
+ return null;
+ }
+
+ @Override
+ public abstract Reader constructReader() throws IOException;
+
+ @Override
+ public abstract InputStream constructInputStream() throws IOException;
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2ByteArraySource.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2ByteArraySource.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2ByteArraySource.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2ByteArraySource.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,85 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+
+/**
+ * Simple implementation of {@link Stax2BlockSource} that encapsulates
+ * a byte array.
+ *
+ *
+ */
+public abstract class Stax2Result
+ implements Result
+{
+ protected String mSystemId;
+ protected String mPublicId;
+ protected String mEncoding;
+
+ protected Stax2Result() { }
+
+ /*
+ /////////////////////////////////////////
+ // Public API, simple accessors/mutators
+ /////////////////////////////////////////
+ */
+
+ public String getSystemId() {
+ return mSystemId;
+ }
+
+ public void setSystemId(String id) {
+ mSystemId = id;
+ }
+
+ public String getPublicId() {
+ return mPublicId;
+ }
+
+ public void setPublicId(String id) {
+ mPublicId = id;
+ }
+
+ public String getEncoding() {
+ return mEncoding;
+ }
+
+ public void setEncoding(String enc) {
+ mEncoding = enc;
+ }
+
+
+ /*
+ ///////////////////////////////////////////
+ // Public API, convenience factory methods
+ ///////////////////////////////////////////
+ */
+
+ /**
+ * This method creates a {@link Writer} via which underlying output
+ * target can be written to. Note that caller is responsible for
+ * closing that Writer when it is done reading it.
+ */
+ public abstract Writer constructWriter()
+ throws IOException;
+
+ /**
+ * This method creates an {@link OutputStream} via which underlying output
+ * target can be written to. Note that caller is responsible for
+ * closing that OutputStream when it is done reading it
+ */
+ public abstract OutputStream constructOutputStream()
+ throws IOException;
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2Source.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2Source.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2Source.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2Source.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,107 @@
+package org.codehaus.stax2.io;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.Reader;
+import java.net.URL;
+
+import javax.xml.transform.Source;
+
+/**
+ * This is the base class for additional input sources (implementations
+ * of {@link javax.xml.transform.Source}) that Stax2
+ * {@link org.codehaus.stax2.XMLInputFactory2} implementations should support.
+ *
+ *
+ */
+public abstract class Stax2Source
+ implements Source
+{
+ protected String mSystemId;
+ protected String mPublicId;
+ protected String mEncoding;
+
+ protected Stax2Source() { }
+
+ /*
+ /////////////////////////////////////////
+ // Public API, simple accessors/mutators
+ /////////////////////////////////////////
+ */
+
+ public String getSystemId() {
+ return mSystemId;
+ }
+
+ public void setSystemId(String id) {
+ mSystemId = id;
+ }
+
+ public String getPublicId() {
+ return mPublicId;
+ }
+
+ public void setPublicId(String id) {
+ mPublicId = id;
+ }
+
+ public String getEncoding() {
+ return mEncoding;
+ }
+
+ public void setEncoding(String enc) {
+ mEncoding = enc;
+ }
+
+ /**
+ * @return URL that can be used to resolve references
+ * originating from the content read via this source; may be
+ * null if not known (which is the case for most non-referential
+ * sources)
+ */
+ public abstract URL getReference();
+
+ /*
+ ///////////////////////////////////////////
+ // Public API, convenience factory methods
+ ///////////////////////////////////////////
+ */
+
+ /**
+ * This method creates a {@link Reader} via which underlying input
+ * source can be accessed. Note that caller is responsible for
+ * closing that Reader when it is done reading it.
+ */
+ public abstract Reader constructReader()
+ throws IOException;
+
+ /**
+ * This method creates an {@link InputStream} via which underlying input
+ * source can be accessed. Note that caller is responsible for
+ * closing that InputSource when it is done reading it
+ */
+ public abstract InputStream constructInputStream()
+ throws IOException;
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2StringSource.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2StringSource.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2StringSource.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2StringSource.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,48 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+
+/**
+ * Simple implementation of {@link Stax2BlockSource} that encapsulates
+ * a simple {@link String}.
+ */
+public class Stax2StringSource
+ extends Stax2BlockSource
+{
+ final String mText;
+
+ public Stax2StringSource(String text) {
+ mText = text;
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Implementation of the Public API
+ /////////////////////////////////////////
+ */
+
+ @Override
+ public Reader constructReader() throws IOException
+ {
+ return new StringReader(mText);
+ }
+
+ @Override
+ public InputStream constructInputStream() throws IOException
+ {
+ /* No obvious/easy way; if caller really wants an InputStream, it
+ * can get a Reader, add an encoders, and so on.
+ */
+ return null;
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Additional API for this source
+ /////////////////////////////////////////
+ */
+
+ public String getText() {
+ return mText;
+ }
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2URLSource.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2URLSource.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/io/Stax2URLSource.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/io/Stax2URLSource.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,57 @@
+package org.codehaus.stax2.io;
+
+import java.io.*;
+import java.net.URL;
+
+/**
+ * Simple implementation of {@link Stax2ReferentialSource}, which refers
+ * to the specific file.
+ */
+public class Stax2URLSource
+ extends Stax2ReferentialSource
+{
+ final URL mURL;
+
+ public Stax2URLSource(URL url) {
+ mURL = url;
+ }
+
+ /*
+ /////////////////////////////////////////
+ // Public API, simple accessors/mutators
+ /////////////////////////////////////////
+ */
+
+ /**
+ * @return URL that refers to the reference resource, for the purposes
+ * of resolving a relative reference from content read from the
+ * resource.
+ */
+ @Override
+ public URL getReference() {
+ return mURL;
+ }
+
+ @Override
+ public Reader constructReader() throws IOException
+ {
+ String enc = getEncoding();
+ if (enc != null && enc.length() > 0) {
+ return new InputStreamReader(constructInputStream(), enc);
+ }
+ // Sub-optimal; really shouldn't use the platform default encoding
+ return new InputStreamReader(constructInputStream());
+ }
+
+ @Override
+ public InputStream constructInputStream() throws IOException
+ {
+ /* A simple optimization: if it's a file reference, can use
+ * a more optimal one:
+ */
+ if ("file".equals(mURL.getProtocol())) {
+ return new FileInputStream(mURL.getPath());
+ }
+ return mURL.openStream();
+ }
+}
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/LocationInfo.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/LocationInfo.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/LocationInfo.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/LocationInfo.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,174 @@
+package org.codehaus.stax2;
+
+import javax.xml.stream.Location;
+import javax.xml.stream.XMLStreamException;
+
+/**
+ * Interface that specifies additional access methods for accessing
+ * full location information of an input location within a stream reader.
+ * Access interface may be directly implemented by the reader, or by
+ * another (reusable or per-call-instantiated) helper object.
+ *streamReader.next
, it it possible that
+ * the previously accessed LocationInfo points to the old information, new
+ * information, or may even contain just garbage. That is, for each new
+ * event, getLocationInfo
should be called separately.
+ */
+public interface LocationInfo
+{
+ /*
+ /////////////////////////////////////////////////////
+ // Low-level extended "raw" location access methods
+ /////////////////////////////////////////////////////
+ */
+
+ /**
+ * Method that can be used to get exact byte offset (number of bytes
+ * read from the stream right before getting to this location) in the
+ * stream that is pointed to by this reader, right before the start
+ * of the current event.
+ *javax.xml.transform.dom.DOMSource
. It can however be
+ * used for both full documents, and single element root fragments,
+ * depending on what node is passed as the argument.
+ *
+ *
+ */
+public abstract class DOMWrappingReader
+ implements XMLStreamReader2,
+ AttributeInfo, DTDInfo, LocationInfo,
+ NamespaceContext,
+ XMLStreamConstants
+{
+ protected final static int INT_SPACE = 0x0020;
+
+ // // // Bit masks used for quick type comparisons
+
+ final private static int MASK_GET_TEXT =
+ (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE)
+ | (1 << COMMENT) | (1 << DTD) | (1 << ENTITY_REFERENCE);
+
+ final private static int MASK_GET_TEXT_XXX =
+ (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE) | (1 << COMMENT);
+
+ final private static int MASK_GET_ELEMENT_TEXT =
+ (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE)
+ | (1 << ENTITY_REFERENCE);
+
+ final protected static int MASK_TYPED_ACCESS_BINARY =
+ (1 << START_ELEMENT) // note: END_ELEMENT handled separately
+ | (1 << CHARACTERS) | (1 << CDATA) | (1 << SPACE)
+ ;
+
+ // // // Enumerated error case ids
+
+ /**
+ * Current state not START_ELEMENT, should be
+ */
+ protected final static int ERR_STATE_NOT_START_ELEM = 1;
+
+ /**
+ * Current state not START_ELEMENT or END_ELEMENT, should be
+ */
+ protected final static int ERR_STATE_NOT_ELEM = 2;
+
+ /**
+ * Current state not PROCESSING_INSTRUCTION
+ */
+ protected final static int ERR_STATE_NOT_PI = 3;
+
+ /**
+ * Current state not one where getText() can be used
+ */
+ protected final static int ERR_STATE_NOT_TEXTUAL = 4;
+
+ /**
+ * Current state not one where getTextXxx() can be used
+ */
+ protected final static int ERR_STATE_NOT_TEXTUAL_XXX = 5;
+
+ protected final static int ERR_STATE_NOT_TEXTUAL_OR_ELEM = 6;
+
+ protected final static int ERR_STATE_NO_LOCALNAME = 7;
+
+ // // // Configuration:
+
+ protected final String _systemId;
+
+ protected final Node _rootNode;
+
+ /**
+ * Whether stream reader is to be namespace aware (as per property
+ * {@link XMLInputFactory#IS_NAMESPACE_AWARE}) or not
+ */
+ protected final boolean _cfgNsAware;
+
+ /**
+ * Whether stream reader is to coalesce adjacent textual
+ * (CHARACTERS, SPACE, CDATA) events (as per property
+ * {@link XMLInputFactory#IS_COALESCING}) or not
+ */
+ protected final boolean _coalescing;
+
+ /**
+ * By default we do not force interning of names: can be
+ * reset by sub-classes.
+ */
+ protected boolean _cfgInternNames = false;
+
+ /**
+ * By default we do not force interning of namespace URIs: can be
+ * reset by sub-classes.
+ */
+ protected boolean _cfgInternNsURIs = false;
+
+ // // // State:
+
+ protected int _currEvent = START_DOCUMENT;
+
+ /**
+ * Current node is the DOM node that contains information
+ * regarding the current event.
+ */
+ protected Node _currNode;
+
+ protected int _depth = 0;
+
+ /**
+ * In coalescing mode, we may need to combine textual content
+ * from multiple adjacent nodes. Since we shouldn't be modifying
+ * the underlying DOM tree, need to accumulate it into a temporary
+ * variable
+ */
+ protected String _coalescedText;
+
+ /**
+ * Helper object used for combining segments of text as needed
+ */
+ protected Stax2Util.TextBuffer _textBuffer = new Stax2Util.TextBuffer();
+
+ // // // Attribute/namespace declaration state
+
+ /* DOM, alas, does not distinguish between namespace declarations
+ * and attributes (due to its roots prior to XML namespaces?).
+ * Because of this, two lists need to be separated. Since this
+ * information is often not needed, it will be lazily generated.
+ */
+
+ /**
+ * Lazily instantiated List of all actual attributes for the
+ * current (start) element, NOT including namespace declarations.
+ * As such, elements are {@link org.w3c.dom.Attr} instances.
+ *
+ * Reads the content of a text-only element, an exception is thrown if
+ * this is not a text-only element.
+ * Regardless of value of javax.xml.stream.isCoalescing this method always
+ * returns coalesced content.
+ *
+ */
+ public String getElementText()
+ throws XMLStreamException
+ {
+ if (_currEvent != START_ELEMENT) {
+ /* Quite illogical: this is not an IllegalStateException
+ * like other similar ones, but rather an XMLStreamException.
+ * But that's how Stax JavaDocs outline how it should be.
+ */
+ reportParseProblem(ERR_STATE_NOT_START_ELEM);
+ }
+ // As per [WSTX-244], handling of coalescing, regular differ a lot, so:
+ if (_coalescing) {
+ String text = null;
+ // Need to loop to get rid of PIs, comments
+ while (true) {
+ int type = next();
+ if (type == END_ELEMENT) {
+ break;
+ }
+ if (type == COMMENT || type == PROCESSING_INSTRUCTION) {
+ continue;
+ }
+ if (((1 << type) & MASK_GET_ELEMENT_TEXT) == 0) {
+ reportParseProblem(ERR_STATE_NOT_TEXTUAL);
+ }
+ if (text == null) {
+ text = getText();
+ } else { // uncommon but possible (with comments, PIs):
+ text = text + getText();
+ }
+ }
+ return (text == null) ? "" : text;
+ }
+ _textBuffer.reset();
+ // Need to loop to get rid of PIs, comments
+ while (true) {
+ int type = next();
+ if (type == END_ELEMENT) {
+ break;
+ }
+ if (type == COMMENT || type == PROCESSING_INSTRUCTION) {
+ continue;
+ }
+ if (((1 << type) & MASK_GET_ELEMENT_TEXT) == 0) {
+ reportParseProblem(ERR_STATE_NOT_TEXTUAL);
+ }
+ _textBuffer.append(getText());
+ }
+ return _textBuffer.get();
+ }
+
+ /**
+ * Returns type of the last event returned; or START_DOCUMENT before
+ * any events has been explicitly returned.
+ */
+ public int getEventType()
+ {
+ return _currEvent;
+ }
+
+ public String getLocalName()
+ {
+ if (_currEvent == START_ELEMENT || _currEvent == END_ELEMENT) {
+ return _internName(_safeGetLocalName(_currNode));
+ }
+ if (_currEvent != ENTITY_REFERENCE) {
+ reportWrongState(ERR_STATE_NO_LOCALNAME);
+ }
+ return _internName(_currNode.getNodeName());
+ }
+
+ public final Location getLocation() {
+ return getStartLocation();
+ }
+
+ public QName getName()
+ {
+ if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
+ reportWrongState(ERR_STATE_NOT_START_ELEM);
+ }
+ return _constructQName(_currNode.getNamespaceURI(), _safeGetLocalName(_currNode), _currNode.getPrefix());
+ }
+
+ // // // Namespace access
+
+ public NamespaceContext getNamespaceContext() {
+ return this;
+ }
+
+ public int getNamespaceCount()
+ {
+ if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
+ reportWrongState(ERR_STATE_NOT_ELEM);
+ }
+ if (_nsDeclList == null) {
+ if (!_cfgNsAware) {
+ return 0;
+ }
+ _calcNsAndAttrLists(_currEvent == START_ELEMENT);
+ }
+ return _nsDeclList.size() / 2;
+ }
+
+ /**
+ * Alas, DOM does not expose any of information necessary for
+ * determining actual declarations. Thus, have to indicate that
+ * there are no declarations.
+ */
+ public String getNamespacePrefix(int index) {
+ if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
+ reportWrongState(ERR_STATE_NOT_ELEM);
+ }
+ if (_nsDeclList == null) {
+ if (!_cfgNsAware) {
+ handleIllegalNsIndex(index);
+ }
+ _calcNsAndAttrLists(_currEvent == START_ELEMENT);
+ }
+ if (index < 0 || (index + index) >= _nsDeclList.size()) {
+ handleIllegalNsIndex(index);
+ }
+ // Note: _nsDeclList entries have been appropriately intern()ed if need be
+ return (String) _nsDeclList.get(index + index);
+ }
+
+ public String getNamespaceURI() {
+ if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
+ reportWrongState(ERR_STATE_NOT_ELEM);
+ }
+ return _internNsURI(_currNode.getNamespaceURI());
+ }
+
+ public String getNamespaceURI(int index) {
+ if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
+ reportWrongState(ERR_STATE_NOT_ELEM);
+ }
+ if (_nsDeclList == null) {
+ if (!_cfgNsAware) {
+ handleIllegalNsIndex(index);
+ }
+ _calcNsAndAttrLists(_currEvent == START_ELEMENT);
+ }
+ if (index < 0 || (index + index) >= _nsDeclList.size()) {
+ handleIllegalNsIndex(index);
+ }
+ // Note: _nsDeclList entries have been appropriately intern()ed if need be
+ return (String) _nsDeclList.get(index + index + 1);
+ }
+
+ // Note: implemented as part of NamespaceContext
+ //public String getNamespaceURI(String prefix)
+
+ public String getPIData() {
+ if (_currEvent != PROCESSING_INSTRUCTION) {
+ reportWrongState(ERR_STATE_NOT_PI);
+ }
+ return _currNode.getNodeValue();
+ }
+
+ public String getPITarget() {
+ if (_currEvent != PROCESSING_INSTRUCTION) {
+ reportWrongState(ERR_STATE_NOT_PI);
+ }
+ return _internName(_currNode.getNodeName());
+ }
+
+ public String getPrefix() {
+ if (_currEvent != START_ELEMENT && _currEvent != END_ELEMENT) {
+ reportWrongState(ERR_STATE_NOT_ELEM);
+ }
+ return _internName(_currNode.getPrefix());
+ }
+
+ public String getText()
+ {
+ if (_coalescedText != null) {
+ return _coalescedText;
+ }
+ if (((1 << _currEvent) & MASK_GET_TEXT) == 0) {
+ reportWrongState(ERR_STATE_NOT_TEXTUAL);
+ }
+ return _currNode.getNodeValue();
+ }
+
+ public char[] getTextCharacters()
+ {
+ String text = getText();
+ return text.toCharArray();
+ }
+
+ public int getTextCharacters(int sourceStart, char[] target, int targetStart, int len)
+ {
+ if (((1 << _currEvent) & MASK_GET_TEXT_XXX) == 0) {
+ reportWrongState(ERR_STATE_NOT_TEXTUAL_XXX);
+ }
+ String text = getText();
+ if (len > text.length()) {
+ len = text.length();
+ }
+ text.getChars(sourceStart, sourceStart+len, target, targetStart);
+ return len;
+ }
+
+ public int getTextLength()
+ {
+ if (((1 << _currEvent) & MASK_GET_TEXT_XXX) == 0) {
+ reportWrongState(ERR_STATE_NOT_TEXTUAL_XXX);
+ }
+ return getText().length();
+ }
+
+ public int getTextStart()
+ {
+ if (((1 << _currEvent) & MASK_GET_TEXT_XXX) == 0) {
+ reportWrongState(ERR_STATE_NOT_TEXTUAL_XXX);
+ }
+ return 0;
+ }
+
+ public boolean hasName() {
+ return (_currEvent == START_ELEMENT) || (_currEvent == END_ELEMENT);
+ }
+
+ public boolean hasNext() {
+ return (_currEvent != END_DOCUMENT);
+ }
+
+ public boolean hasText() {
+ return (((1 << _currEvent) & MASK_GET_TEXT) != 0);
+ }
+
+ public boolean isAttributeSpecified(int index)
+ {
+ if (_currEvent != START_ELEMENT) {
+ reportWrongState(ERR_STATE_NOT_START_ELEM);
+ }
+ Element elem = (Element) _currNode;
+ Attr attr = (Attr) elem.getAttributes().item(index);
+ if (attr == null) {
+ handleIllegalAttrIndex(index);
+ return false;
+ }
+ return attr.getSpecified();
+ }
+
+ public boolean isCharacters()
+ {
+ return (_currEvent == CHARACTERS);
+ }
+
+ public boolean isEndElement() {
+ return (_currEvent == END_ELEMENT);
+ }
+
+ public boolean isStartElement() {
+ return (_currEvent == START_ELEMENT);
+ }
+
+ public boolean isWhiteSpace()
+ {
+ if (_currEvent == CHARACTERS || _currEvent == CDATA) {
+ String text = getText();
+ for (int i = 0, len = text.length(); i < len; ++i) {
+ /* !!! If xml 1.1 was to be handled, should check for
+ * LSEP and NEL too?
+ */
+ if (text.charAt(i) > INT_SPACE) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return (_currEvent == SPACE);
+ }
+
+ public void require(int type, String nsUri, String localName)
+ throws XMLStreamException
+ {
+ int curr = _currEvent;
+
+ /* There are some special cases; specifically, SPACE and CDATA
+ * are sometimes reported as CHARACTERS. Let's be lenient by
+ * allowing both 'real' and reported types, for now.
+ */
+ if (curr != type) {
+ if (curr == CDATA) {
+ curr = CHARACTERS;
+ } else if (curr == SPACE) {
+ curr = CHARACTERS;
+ }
+ }
+
+ if (type != curr) {
+ throwStreamException("Required type "+Stax2Util.eventTypeDesc(type)
+ +", current type "
+ +Stax2Util.eventTypeDesc(curr));
+ }
+
+ if (localName != null) {
+ if (curr != START_ELEMENT && curr != END_ELEMENT
+ && curr != ENTITY_REFERENCE) {
+ throwStreamException("Required a non-null local name, but current token not a START_ELEMENT, END_ELEMENT or ENTITY_REFERENCE (was "+Stax2Util.eventTypeDesc(_currEvent)+")");
+ }
+ String n = getLocalName();
+ if (n != localName && !n.equals(localName)) {
+ throwStreamException("Required local name '"+localName+"'; current local name '"+n+"'.");
+ }
+ }
+ if (nsUri != null) {
+ if (curr != START_ELEMENT && curr != END_ELEMENT) {
+ throwStreamException("Required non-null NS URI, but current token not a START_ELEMENT or END_ELEMENT (was "+Stax2Util.eventTypeDesc(curr)+")");
+ }
+
+ String uri = getNamespaceURI();
+ // No namespace?
+ if (nsUri.length() == 0) {
+ if (uri != null && uri.length() > 0) {
+ throwStreamException("Required empty namespace, instead have '"+uri+"'.");
+ }
+ } else {
+ if ((nsUri != uri) && !nsUri.equals(uri)) {
+ throwStreamException("Required namespace '"+nsUri+"'; have '"
+ +uri+"'.");
+ }
+ }
+ }
+ // Ok, fine, all's good
+ }
+
+ /*
+ /**********************************************************************
+ /* XMLStreamReader, iterating
+ /**********************************************************************
+ */
+
+ public int next()
+ throws XMLStreamException
+ {
+ _coalescedText = null;
+
+ /* For most events, we just need to find the next sibling; and
+ * that failing, close the parent element. But there are couple
+ * of special cases, which are handled first:
+ */
+ switch (_currEvent) {
+
+ case START_DOCUMENT: // initial state
+ /* What to do here depends on what kind of node we started
+ * with...
+ */
+ switch (_currNode.getNodeType()) {
+ case Node.DOCUMENT_NODE:
+ case Node.DOCUMENT_FRAGMENT_NODE:
+ // For doc, fragment, need to find first child
+ _currNode = _currNode.getFirstChild();
+ // as per [WSTX-259], need to handle degenerate case of empty fragment, too
+ if (_currNode == null) {
+ return (_currEvent = END_DOCUMENT);
+ }
+ break;
+
+ case Node.ELEMENT_NODE:
+ // For element, curr node is fine:
+ return (_currEvent = START_ELEMENT);
+
+ default:
+ throw new XMLStreamException("Internal error: unexpected DOM root node type "+_currNode.getNodeType()+" for node '"+_currNode+"'");
+ }
+ break;
+
+ case END_DOCUMENT: // end reached: should not call!
+ throw new java.util.NoSuchElementException("Can not call next() after receiving END_DOCUMENT");
+
+ case START_ELEMENT: // element returned, need to traverse children, if any
+ ++_depth;
+ _attrList = null; // so it will not get reused accidentally
+ {
+ Node firstChild = _currNode.getFirstChild();
+ if (firstChild == null) { // empty? need to return virtual END_ELEMENT
+ /* Note: need not clear namespace declarations, because
+ * it'll be the same as for the start elem!
+ */
+ return (_currEvent = END_ELEMENT);
+ }
+ _nsDeclList = null;
+
+ /* non-empty is easy: let's just swap curr node, and
+ * fall through to regular handling
+ */
+ _currNode = firstChild;
+ break;
+ }
+
+ case END_ELEMENT:
+
+ --_depth;
+ // Need to clear these lists
+ _attrList = null;
+ _nsDeclList = null;
+
+ /* One special case: if we hit the end of children of
+ * the root element (when tree constructed with Element,
+ * instead of Document or DocumentFragment). If so, it'll
+ * be END_DOCUMENT:
+ */
+ if (_currNode == _rootNode) {
+ return (_currEvent = END_DOCUMENT);
+ }
+ // Otherwise need to fall through to default handling:
+
+ default:
+ /* For anything else, we can and should just get the
+ * following sibling.
+ */
+ {
+ Node next = _currNode.getNextSibling();
+ // If sibling, let's just assign and fall through
+ if (next != null) {
+ _currNode = next;
+ break;
+ }
+ /* Otherwise, need to climb up _the stack and either
+ * return END_ELEMENT (if parent is element) or
+ * END_DOCUMENT (if not; needs to be root, then)
+ */
+ _currNode = _currNode.getParentNode();
+ int type = _currNode.getNodeType();
+ if (type == Node.ELEMENT_NODE) {
+ return (_currEvent = END_ELEMENT);
+ }
+ // Let's do sanity check; should really be Doc/DocFragment
+ if (_currNode != _rootNode ||
+ (type != Node.DOCUMENT_NODE && type != Node.DOCUMENT_FRAGMENT_NODE)) {
+ throw new XMLStreamException("Internal error: non-element parent node ("+type+") that is not the initial root node");
+ }
+ return (_currEvent = END_DOCUMENT);
+ }
+ }
+
+ // Ok, need to determine current node type:
+ switch (_currNode.getNodeType()) {
+ case Node.CDATA_SECTION_NODE:
+ if (_coalescing) {
+ coalesceText(CDATA);
+ } else {
+ _currEvent = CDATA;
+ }
+ break;
+ case Node.COMMENT_NODE:
+ _currEvent = COMMENT;
+ break;
+ case Node.DOCUMENT_TYPE_NODE:
+ _currEvent = DTD;
+ break;
+ case Node.ELEMENT_NODE:
+ _currEvent = START_ELEMENT;
+ break;
+ case Node.ENTITY_REFERENCE_NODE:
+ _currEvent = ENTITY_REFERENCE;
+ break;
+ case Node.PROCESSING_INSTRUCTION_NODE:
+ _currEvent = PROCESSING_INSTRUCTION;
+ break;
+ case Node.TEXT_NODE:
+ if (_coalescing) {
+ coalesceText(CHARACTERS);
+ } else {
+ _currEvent = CHARACTERS;
+ }
+ break;
+
+ // Should not get other nodes (notation/entity decl., attr)
+ case Node.ATTRIBUTE_NODE:
+ case Node.ENTITY_NODE:
+ case Node.NOTATION_NODE:
+ throw new XMLStreamException("Internal error: unexpected DOM node type "+_currNode.getNodeType()+" (attr/entity/notation?), for node '"+_currNode+"'");
+
+ default:
+ throw new XMLStreamException("Internal error: unrecognized DOM node type "+_currNode.getNodeType()+", for node '"+_currNode+"'");
+ }
+
+ return _currEvent;
+ }
+
+ public int nextTag()
+ throws XMLStreamException
+ {
+ while (true) {
+ int next = next();
+
+ switch (next) {
+ case SPACE:
+ case COMMENT:
+ case PROCESSING_INSTRUCTION:
+ continue;
+ case CDATA:
+ case CHARACTERS:
+ if (isWhiteSpace()) {
+ continue;
+ }
+ throwStreamException("Received non-all-whitespace CHARACTERS or CDATA event in nextTag().");
+ break; // never gets here, but jikes complains without
+ case START_ELEMENT:
+ case END_ELEMENT:
+ return next;
+ }
+ throwStreamException("Received event "+Stax2Util.eventTypeDesc(next)
+ +", instead of START_ELEMENT or END_ELEMENT.");
+ }
+ }
+
+ /**
+ *
Precondition: the current event is START_ELEMENT.
+ *
Postcondition: the current event is the corresponding END_ELEMENT.
+ *this
.
+ */
+ public DTDInfo getDTDInfo() throws XMLStreamException
+ {
+ /* Let's not allow it to be accessed during other events -- that
+ * way callers won't count on it being available afterwards.
+ */
+ if (_currEvent != DTD) {
+ return null;
+ }
+ return this;
+ }
+
+ // // // StAX2, Additional location information
+
+ /**
+ * Location information is always accessible, for this reader.
+ */
+ public final LocationInfo getLocationInfo() {
+ return this;
+ }
+
+ // // // StAX2, Pass-through text accessors
+
+
+ /**
+ * Method similar to {@link #getText()}, except
+ * that it just uses provided Writer to write all textual content.
+ * For further optimization, it may also be allowed to do true
+ * pass-through, thus possibly avoiding one temporary copy of the
+ * data.
+ *getText
will return
+ * proper conntets. If false, reader is allowed to skip creation
+ * of such copies: this can improve performance, but it also means
+ * that further calls to getText
is not guaranteed to
+ * return meaningful data.
+ *
+ * @return Number of characters written to the reader
+ */
+ public int getText(Writer w, boolean preserveContents)
+ throws IOException, XMLStreamException
+ {
+ String text = getText();
+ w.write(text);
+ return text.length();
+ }
+
+ // // // StAX 2, Other accessors
+
+ /**
+ * @return Number of open elements in the stack; 0 when parser is in
+ * prolog/epilog, 1 inside root element and so on.
+ */
+ public int getDepth() {
+ return _depth;
+ }
+
+ /**
+ * @return True, if cursor points to a start or end element that is
+ * constructed from 'empty' element (ends with {@code '/>'});
+ * false otherwise.
+ */
+ public boolean isEmptyElement() throws XMLStreamException
+ {
+ // No way to really figure it out via DOM is there?
+ return false;
+ }
+
+ public NamespaceContext getNonTransientNamespaceContext()
+ {
+ /* Since DOM does not expose enough functionality to figure
+ * out complete declaration stack, can not implement.
+ * Can either return null, or a dummy instance. For now, let's
+ * do latter:
+ */
+ return EmptyNamespaceContext.getInstance();
+ }
+
+ public String getPrefixedName()
+ {
+ switch (_currEvent) {
+ case START_ELEMENT:
+ case END_ELEMENT:
+ {
+ String prefix = _currNode.getPrefix();
+ String ln = _safeGetLocalName(_currNode);
+
+ if (prefix == null) {
+ return _internName(ln);
+ }
+ StringBuffer sb = new StringBuffer(ln.length() + 1 + prefix.length());
+ sb.append(prefix);
+ sb.append(':');
+ sb.append(ln);
+ return _internName(sb.toString());
+ }
+ case ENTITY_REFERENCE:
+ return getLocalName();
+ case PROCESSING_INSTRUCTION:
+ return getPITarget();
+ case DTD:
+ return getDTDRootName();
+
+ }
+ throw new IllegalStateException("Current state ("+Stax2Util.eventTypeDesc(_currEvent)+") not START_ELEMENT, END_ELEMENT, ENTITY_REFERENCE, PROCESSING_INSTRUCTION or DTD");
+ }
+
+ public void closeCompletely() throws XMLStreamException
+ {
+ // Nothing special to do...
+ }
+
+ /*
+ /**********************************************************************
+ /* DTDInfo implementation (StAX 2)
+ /**********************************************************************
+ */
+
+ public Object getProcessedDTD() {
+ return null;
+ }
+
+ public String getDTDRootName() {
+ if (_currEvent == DTD) {
+ return _internName(((DocumentType) _currNode).getName());
+ }
+ return null;
+ }
+
+ public String getDTDPublicId() {
+ if (_currEvent == DTD) {
+ return ((DocumentType) _currNode).getPublicId();
+ }
+ return null;
+ }
+
+ public String getDTDSystemId() {
+ if (_currEvent == DTD) {
+ return ((DocumentType) _currNode).getSystemId();
+ }
+ return null;
+ }
+
+ /**
+ * @return Internal subset portion of the DOCTYPE declaration, if any;
+ * empty String if none
+ */
+ public String getDTDInternalSubset() {
+ /* DOM (level 3) doesn't expose anything extra; would need to
+ * synthetize subset... which would only contain some of the
+ * entity and notation declarations.
+ */
+ return null;
+ }
+
+ // // StAX2, v2.0
+
+ public DTDValidationSchema getProcessedDTDSchema() {
+ return null;
+ }
+
+ /*
+ /**********************************************************************
+ /* LocationInfo implementation (StAX 2)
+ /**********************************************************************
+ */
+
+ // // // First, the "raw" offset accessors:
+
+ public long getStartingByteOffset() {
+ // !!! TBI
+ return -1L;
+ }
+
+ public long getStartingCharOffset() {
+ // !!! TBI
+ return 0;
+ }
+
+ public long getEndingByteOffset() throws XMLStreamException
+ {
+ // !!! TBI
+ return -1;
+ }
+
+ public long getEndingCharOffset() throws XMLStreamException
+ {
+ // !!! TBI
+ return -1;
+ }
+
+ // // // and then the object-based access methods:
+
+ public XMLStreamLocation2 getStartLocation()
+ {
+ return XMLStreamLocation2.NOT_AVAILABLE;
+ }
+
+ public XMLStreamLocation2 getCurrentLocation()
+ {
+ return XMLStreamLocation2.NOT_AVAILABLE;
+ }
+
+ public final XMLStreamLocation2 getEndLocation()
+ throws XMLStreamException
+ {
+ return XMLStreamLocation2.NOT_AVAILABLE;
+ }
+
+ /*
+ /**********************************************************************
+ /* Stax2 validation: !!! TODO
+ /**********************************************************************
+ */
+
+ public XMLValidator validateAgainst(XMLValidationSchema schema)
+ throws XMLStreamException
+ {
+ // Not implemented by the basic reader:
+ return null;
+ }
+
+ public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
+ throws XMLStreamException
+ {
+ // Not implemented by the basic reader:
+ return null;
+ }
+
+ public XMLValidator stopValidatingAgainst(XMLValidator validator)
+ throws XMLStreamException
+ {
+ // Not implemented by the basic reader:
+ return null;
+ }
+
+ public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
+ {
+ // Not implemented by the basic reader
+ return null;
+ }
+
+ /*
+ ////////////////////////////////////////////
+ // Internal methods, text gathering
+ ////////////////////////////////////////////
+ */
+
+ protected void coalesceText(int initialType)
+ {
+ _textBuffer.reset();
+ _textBuffer.append(_currNode.getNodeValue());
+
+ Node n;
+ while ((n = _currNode.getNextSibling()) != null) {
+ int type = n.getNodeType();
+ if (type != Node.TEXT_NODE && type != Node.CDATA_SECTION_NODE) {
+ break;
+ }
+ _currNode = n;
+ _textBuffer.append(_currNode.getNodeValue());
+ }
+ _coalescedText = _textBuffer.get();
+
+ // Either way, type gets always set to be CHARACTERS
+ _currEvent = CHARACTERS;
+ }
+
+ /*
+ /**********************************************************************
+ /* Internal methods, namespace support
+ /**********************************************************************
+ */
+
+ private QName _constructQName(String uri, String ln, String prefix)
+ {
+ // Stupid QName impls barf on nulls...
+ return new QName(_internNsURI(uri), _internName(ln), _internName(prefix));
+ }
+
+ /**
+ * @param attrsToo Whether to include actual attributes too, or
+ * just namespace declarations
+ */
+ private void _calcNsAndAttrLists(boolean attrsToo)
+ {
+ NamedNodeMap attrsIn = _currNode.getAttributes();
+
+ // A common case: neither attrs nor ns decls, can use short-cut
+ int len = attrsIn.getLength();
+ if (len == 0) {
+ _attrList = Collections.emptyList();
+ _nsDeclList = Collections.emptyList();
+ return;
+ }
+
+ if (!_cfgNsAware) {
+ _attrList = new ArrayListfindErrorDesc()
first, and only
+ * if no message found, uses default messages defined here.
+ */
+ protected String findErrorDesc(int errorType, int currEvent)
+ {
+ String evtDesc = Stax2Util.eventTypeDesc(currEvent);
+ switch (errorType) {
+ case ERR_STATE_NOT_START_ELEM:
+ return "Current event "+evtDesc+", needs to be START_ELEMENT";
+ case ERR_STATE_NOT_ELEM:
+ return "Current event "+evtDesc+", needs to be START_ELEMENT or END_ELEMENT";
+ case ERR_STATE_NO_LOCALNAME:
+ return "Current event ("+evtDesc+") has no local name";
+ case ERR_STATE_NOT_PI:
+ return "Current event ("+evtDesc+") needs to be PROCESSING_INSTRUCTION";
+
+ case ERR_STATE_NOT_TEXTUAL:
+ return "Current event ("+evtDesc+") not a textual event";
+ case ERR_STATE_NOT_TEXTUAL_OR_ELEM:
+ return "Current event ("+evtDesc+" not START_ELEMENT, END_ELEMENT, CHARACTERS or CDATA";
+ case ERR_STATE_NOT_TEXTUAL_XXX:
+ return "Current event "+evtDesc+", needs to be one of CHARACTERS, CDATA, SPACE or COMMENT";
+ }
+ // should never happen, but it'd be bad to throw another exception...
+ return "Internal error (unrecognized error type: "+errorType+")";
+ }
+
+ /**
+ * Method called to do additional intern()ing for a name, if and as
+ * necessary
+ */
+ protected String _internName(String name)
+ {
+ if (name == null) {
+ return "";
+ }
+ return _cfgInternNames ? name.intern() : name;
+ }
+
+ protected String _internNsURI(String uri)
+ {
+ if (uri == null) {
+ return "";
+ }
+ return _cfgInternNsURIs ? uri.intern() : uri;
+ }
+}
+
diff -Nru libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/ri/dom/DOMWrappingWriter.java libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/ri/dom/DOMWrappingWriter.java
--- libstax2-api-java-3.1.1/src/main/java/org/codehaus/stax2/ri/dom/DOMWrappingWriter.java 1970-01-01 00:00:00.000000000 +0000
+++ libstax2-api-java-4.1/src/main/java/org/codehaus/stax2/ri/dom/DOMWrappingWriter.java 2018-03-28 03:39:47.000000000 +0000
@@ -0,0 +1,684 @@
+/* Stax2 API extension for Streaming Api for Xml processing (StAX).
+ *
+ * Copyright (c) 2006- Tatu Saloranta, tatu.saloranta@iki.fi
+ *
+ * Licensed under the License specified in the file LICENSE which is
+ * included with the source code.
+ * You may not use this file except in compliance with the License.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.codehaus.stax2.ri.dom;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.text.MessageFormat;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.stream.*;
+
+import org.w3c.dom.*;
+
+import org.codehaus.stax2.XMLStreamLocation2;
+import org.codehaus.stax2.XMLStreamReader2;
+import org.codehaus.stax2.XMLStreamWriter2;
+import org.codehaus.stax2.ri.typed.SimpleValueEncoder;
+import org.codehaus.stax2.typed.Base64Variant;
+import org.codehaus.stax2.typed.Base64Variants;
+import org.codehaus.stax2.validation.*;
+
+/**
+ * This is an adapter class that partially implements {@link XMLStreamWriter}
+ * as a facade on top of a DOM document or Node, allowing one
+ * to basically construct DOM trees via Stax API.
+ * It is meant to serve as basis for a full implementation.
+ *javax.xml.transform.dom.DOMResult
. It can however be
+ * used for both full documents, and single element root fragments,
+ * depending on what node is passed as the argument.
+ *