|
|||||||||
PREV NEXT | FRAMES NO FRAMES |
EncodingXmlWriter
used when output
is to be encoded using 7-bit ascii (US-ASCII) encoding.WstxInputSource
implementations Woodstox includes need.XMLStreamWriter
implementations Woodstox has.XMLStreamReader2
consisting of
all functionality other than DTD-validation-specific parts, and
Typed Access API (Stax2 v3.0), which are implemented at
sub-classes.XmlWriter
that will dispatch writes
to another writer (of type Writer
, and will NOT handle
encoding.Location
information or not.
XMLStreamReader.getNamespaceContext()
,
except that this method also does close the underlying input
source if it has not yet been closed.
XMLStreamWriter.close()
,
except that this method also does close the underlying output
destination (stream) if it has not yet been closed.
StartElement
implementation used when directly creating
events from a stream reader.XMLStreamException
to throw
as a result of a failed Typed Access operation (but one not
caused by a Well-Formedness Constraint or Validation Constraint
problem)
InputStream
via which underlying input
source can be accessed.
OutputStream
via which underlying output
target can be written to.
Reader
via which underlying input
source can be accessed.
Writer
via which underlying output
target can be written to.
CONTENT_ALLOW_WS_NONSTRICT
,
but only used for content typing purposes, not for validation.
TextBuffer.contentsAsString()
, but constructs a StringBuffer
for further appends.
XMLInputFactory2
instance.
XMLOutputFactory2
instance.
WstxOutputFactory.createSW(OutputStream, Writer, String, boolean)
after all of the nessesary configuration
logic is complete.
XMLValidationSchemaFactory
instance.
XMLEventAllocator
, to be
used with Woodstox' event reader.XMLStreamReader
.XMLStreamWriter
as a facade on top of a DOM document or Node, allowing one
to basically construct DOM trees via Stax API.DTD
with methods that are
necessary to completely reproduce actual DOCTYPE declaration
constructs in xml documents.DTDAttribute
sub-class used for plain vanilla CDATA
valued attributes.XMLValidationSchema
, as well
as specifies extended Woodstox-specific interface for accessing
DTD-specific things like entity expansions and notation properties.DTDSubset
XMLValidator
; the class that
handles DTD-based validation.XMLValidator
for DTD validation.ElementId
instances.NamespaceContext
(and BaseNsContext
)
implementation that is usually used in
non-namespace-aware mode.NamespaceContext
implementation that contains no
namespace information, except bindings that are specified by
the namespace specification itself (for prefixes "xml" and "xmlns")StreamScanner.loadMore()
.
ValueDecoderFactory.BaseArrayDecoder.hasRoom()
returns false) and
will expand result buffer to hold at least one more value.
XMLInputFactory2.P_DTD_OVERRIDE
instead.
SymbolTable.findSymbol(char[],int,int,int)
; used to either
do potentially cheap intern() (if table already has intern()ed version),
or to pre-populate symbol table with known values.
WstxDOMWrappingWriter.findElemPrefix(java.lang.String, com.ctc.wstx.dom.DOMOutputElement)
has returned null,
to create and bind a namespace mapping for specified namespace.
RepairingNsStreamWriter.findElemPrefix(java.lang.String, com.ctc.wstx.sw.SimpleOutputElement)
has returned null,
to create and bind a namespace mapping for specified namespace.
BasicStreamReader
, to retrieve the
attribute collector it needs for some direct access.
localName
and URI is namespaceURI
or -1
if no such attribute exists.
DTDInfo
, method can just
return this
.
DTDInfo
, method can just
return this
.
TypedXMLStreamReader.readElementAsBinary(byte[], int, int, org.codehaus.stax2.typed.Base64Variant)
, in cases where neither performance nor
memory usage is a big concern.
TypedXMLStreamReader.readElementAsBinary(byte[], int, int, org.codehaus.stax2.typed.Base64Variant)
, in cases where neither performance nor
memory usage is a big concern.
OutputElementBase.getPrefix(java.lang.String)
, but one that will not accept
the default namespace, only an explicit one.
XMLStreamReader.getProperty(java.lang.String)
instead
Location
object to use for
an event to create.
StreamScanner.getNextChar(java.lang.String)
, but will not read more characters
from parent input source(s) if the current input source doesn't
have more content.
XMLStreamReader.getNamespaceContext()
,
but one that is
not transient.
DTDInfo.getProcessedDTD()
, but type-safe.
BasicStreamReader.getText()
, except
that it just uses provided Writer to write all textual content.
DOMWrappingReader.getText()
, except
that it just uses provided Writer to write all textual content.
XMLStreamReader.getText()
, except
that it just uses provided Writer to write all textual content,
and that it works for wider range of event types.
DataUtil.growArrayBy50Pct(java.lang.Object)
, but it also ensures that
the new size is at least as big as the specified minimum size.
XMLStreamException
, the reference implementation
doesn't currently need to.
XMLEventReader.hasNext()
, except that it can
throw a XMLStreamException
.
WstxInputSource
to allow
reading input from various sources.WstxOutputProperties.P_OUTPUT_INVALID_CHAR_HANDLER
.EncodingXmlWriter
used when output
is to be encoded using ISO-8859-1, aka ISO-Latin1 encoding.XMLInputFactory.isPropertySupported(java.lang.String)
, used
to determine whether a property is supported by the Reader
instance.
XMLInputFactory.isPropertySupported(java.lang.String)
, used
to determine whether a property is supported by the Reader
instance.
XMLOutputFactory.isPropertySupported(java.lang.String)
, used
to determine whether a property is supported by the Writer
instance.
PrefixedNameSet
suitable for storing large number
of entries; basically anything above trivially small sets (4 or less).BasicStreamReader.getText()
method
can be called.
getTextXxx
methods can be called; which is less than those for which
BasicStreamReader.getText()
can be called.
DTDValidatorBase.mAttrSpecs
; needed to store in case type information
is requested later on.
Attributes
and
Attributes2
interfaces, for the current start element.
mAttrMap
; generally at least 20%
more than number of attributes (mAttrCount
).
mAttrMap
array.
DTDValidatorBase.checkNsDefaults(com.ctc.wstx.sr.InputElementStack)
is necessary
to pass information regarding the current element; although
it will become available later on (via normal XMLValidator interface),
that's too late (after namespace binding and resolving).
String.charAt()
(which
perhaps surprisingly is often case, and especially significant
for longer buffers).
validateElementStart
,
validateAttribute
,
validateElementAndAttributes
calls.
BasicStreamReader.getEventType()
.
XmlConsts
(like XmlConsts.XML_V_10
).
BaseStreamWriter.writeDTD(java.lang.String)
method.
DTDValidatorBase.mElems
.
BaseStreamWriter.writeStartDocument()
, or null if
neither.
NamespaceContext
implementation used when constructing
event and namespace information explicitly via
XMLEventFactory
,
not by a stream reader.Reader
implementation that is used to "unwind" some
data previously read from a Reader; so that as long as some of
that data remains, it's returned; but as long as it's read, we'll
just use data from the underlying original Reader.InputStream
implementation that is used to "unwind" some
data previously read from an input stream; so that as long as some of
that data remains, it's returned; but as long as it's read, we'll
just use data from the underlying original stream.Base64Variants.MIME
which does not
use linefeeds (max line length set to infinite).
mBuckets.length - 1
, when mBuckets.length is
a power of two.
mBuckets.length - 1
, when mBuckets.length is
a power of two.
WstxSAXParser.mFeatNsPrefixes
).
AttributeCollector.mNamespaces
.
OutputElementBase.mNsMapping
is a shared copy from the parent;
false if a local copy was created (which happens when namespaces
get bound etc).
ContentSpec
objects, when they get rewritten (when their ContentSpec.rewrite()
gets called).writeStartElement
and
writeEmptyElement
, and can be used to
add attributes and namespace declarations.
getText
and its variations), we may need
to delay throwing an exception until BasicStreamReader.next()
is called next
time.
writeRaw
methods of this
XmlWriter instance.
XMLStreamProperties.RETURN_NULL_FOR_DEFAULT_NAMESPACE
BasicStreamReader.mCurrToken
is already populated.
writeRaw
or
writeCharacters
), the first part is temporarily stored
within this member variable.
writeCharacters
methods of this
XmlWriter instance.
AttributeCollector.XMLID_IX_NONE
if none.
Namespace
.XMLStreamWriter
used when namespace support
is not enabled.NotationDeclaration
to add
support for handling Base URI needed to resolve Notation references.XMLValidationSchema
,
such as XMLValidationSchema.SCHEMA_ID_DTD
)
that the schema factory this provider handles supports.
CompactStartElement
to output all 'local' namespace declarations active in current
namespace scope, if any.
close
or
closeCompletely
, or implicitly by a call
to writeEndDocument
.
URL
, that will allow specifying
context URL to use when resolving relative references, for the
main-level entities (external DTD subset, references from the internal
DTD subset).
XMLResolver
, that
will allow overriding of default DTD and external parameter entity
resolution.
XMLResolver
, that
will allow overriding of default external general entity
resolution.
WstxInputProperties.PARSING_MODE_DOCUMENT
,
WstxInputProperties.PARSING_MODE_FRAGMENT
or
WstxInputProperties.PARSING_MODE_DOCUMENTS
; default being the document mode)
that can be used to handle "non-standard" XML content.
XMLInputFactory2.P_LAZY_PARSING
instead (from
Stax2 extension API, v3.0)
XMLStreamReader.next()
is called, and only parse the rest
as needed (or skip remainder of no extra information is needed).
EmptyElementHandler
used to determine
if the end tag for an empty element should be written or not.
WstxOutputProperties.P_OUTPUT_VALIDATE_CONTENT
is enabled, instead of
reporting an error, writer will try to fix the problem.
InvalidCharHandler
used to determine
what to do with a Java character that app tries to output but which
is not a valid xml character.
OutputStream
that an
XMLStreamWriter
instance is using,
if known (not known if constructed with a Writer
,
or other non-stream destination).
Writer
that an
XMLStreamWriter
instance is using,
if known (may not be known if constructed with a OutputStream
,
or other non-Writer destination).
XMLResolver
, that
will allow graceful handling of references to undeclared (general)
entities.
FullDTDReader.parseDirective()
, but one that takes care
to properly output dtd contents via DTDWriter
as necessary.
StreamScanner.getNext()
, but does not advance pointer
in input buffer.
Base64Variants.MIME
: it is otherwise
identical, except that it mandates shorter line length.
MinimalDTDReader.skipComment()
, but that has to collect
contents, to be reported for a SAX handler.
MinimalDTDReader.skipPI()
, but one that does basic
well-formedness checks.
XMLStreamWriter
, that does
namespace repairing, ie resolves possible conflicts between prefixes
(add new bindings as necessary), as well as automatically creates
namespace declarations as necessary.WstxOutputProperties.P_OUTPUT_VALIDATE_NAMES
is
is enabled.
WstxOutputProperties.P_OUTPUT_VALIDATE_CONTENT
is
is enabled.
WstxOutputProperties.P_OUTPUT_VALIDATE_NAMES
is
is enabled.
WstxOutputProperties.P_OUTPUT_VALIDATE_STRUCTURE
is
is enabled.
ValidationContext
TextBuffer.resetWithEmpty()
, but actively marks current
text content to be empty string (whereas former method leaves
content as undefined).
StreamScanner.resolveCharOnlyEntity(boolean)
; will only resolve entity
if it is NOT a character entity (or pre-defined 'generic' entity;
amp, apos, lt, gt or quot).
ModelNode
instances that will
match definition this instance contains.
XMLStreamReader2.setProperty(java.lang.String, java.lang.Object)
instead
XMLInputFactory2
instance.
XMLInputFactory2
instance.
XMLOutputFactory2
instance.
ReaderConfig.setEntityResolver(javax.xml.stream.XMLResolver)
and ReaderConfig.setDtdResolver(javax.xml.stream.XMLResolver)
instead.
ReaderConfig.setEntityResolver(javax.xml.stream.XMLResolver)
instead, if possible, since this just wraps passed in resolver.
XMLStreamWriter
, that does
not do namespace repairing, ie doesn't try to resolve possible
conflicts between prefixes and namespace URIs, or automatically
create namespace bindings.StartElement
implementation used when event is constructed
from already objectified data, for example when constructed by the event
factory.WstxInputSource
from it.
StartElement
implementation used when event is constructed
from already objectified data, for example when constructed by the event
factory.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.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.Stax2BlockSource
that encapsulates
a byte array.Stax2BlockSource
that encapsulates
an char array.XMLEventAllocator
, to be
used either as is, or as a base for more specialized Stax2
event allocator implementation.XMLEventFactory2
.XMLEventReader2
, the
extended stream reader defined by Stax2 extension, by wrapping
a vanilla Stax 1.0 XMLEventReader
implementation.XMLEventReader2
, built on top of
a generic XMLStreamReader
implementation (using aggregation).XMLEventWriter
.Stax2ReferentialResult
, which refers
to the specific file.Stax2ReferentialSource
, which refers
to the specific file.XMLStreamReader2
).XMLInputFactory2
instances with OSGi framework.XMLStreamLocation2
, which just
wraps Stax 1.0 Location
and adds no-operation implementation
of the additions.XMLOutputFactory2
instances with OSGi framework.XMLStreamReader2
, the
extended stream reader defined by Stax2 extension, by wrapping
a vanilla Stax 1.0 XMLStreamReader
implementation.XMLStreamReader2
,
the extended stream reader that is part of Stax2.Stax2Result
s
that refer to a resource in such a way, that an efficient
OutputStream
or Writer
can be constructed.Stax2Source
s
that refer to a resource in such a way, that an efficient
InputStream
or Reader
can be constructed.Result
) that Stax2
XMLInputFactory2
implementations should support.Source
) that Stax2
XMLInputFactory2
implementations should support.Stax2BlockSource
that encapsulates
a simple String
.Stax2ReferentialSource
, which refers
to the specific file.XMLValidationSchemaFactory
instances with OSGi framework.XMLStreamWriter2
, the
extended stream writer defined by Stax2 extension, by wrapping
a vanilla Stax 1.0 XMLStreamReader
implementation.XMLStreamWriter2
,
the extended stream writer that is part of Stax2.Validatable.validateAgainst(org.codehaus.stax2.validation.XMLValidationSchema)
was called earlier.
StreamReaderDelegate
,
but implements a proxy for XMLStreamWriter
.List
(from storage perspective),
but that can be used in multiple ways.StringBuffer
, with
following differences:
TextBuffer uses segments character arrays, to avoid having
to do additional array copies when array is not big enough.StringBuffer
, except that it can be used to
construct multiple Strings, that will share same underlying character
buffer.StreamScanner.throwUnexpectedEOF(java.lang.String)
, but only indicates ending
of an input block.
XMLValidationException
to throw based on information contained in this object.
TextBuffer.contentsAsString()
, since it's not guaranteed that resulting
String is cached.
XMLStreamReader2
,
including Typed Access API (Stax2 v3.0) implementation.TypedXMLStreamReader
to allow for efficient customized
decoding of textual xml content into actual typed values.TypedXMLStreamReader
or an TypedXMLStreamWriter
.XMLStreamReader
.XMLStreamWriter
.XmlWriter
.DTDValidatorBase
to let the attribute do necessary normalization and/or validation
for the value.
DTDValidatorBase
to let the attribute do necessary normalization and/or validation
for the value.
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
Validatable.stopValidatingAgainst(org.codehaus.stax2.validation.XMLValidationSchema)
.
DTDValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
validateAttribute(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
on all
attributes (if any), but before starting to handle element
content.
XMLStreamReader2
that builds on TypedStreamReader
and adds full DTD-handling
including DTD validationXMLValidator
instances.TypedValueDecoder
(and TypedArrayDecoder
)
instances needed by a
single stream reader instance.AsciiValueEncoder
instances needed by a single
stream writer instance.EntityDecl
instance.DefaultEventAllocator
to get double-indirection necessary for constructing start element
events.
NotationDeclaration2
.writeRaw
method via regular Writer
interface.
writeRaw
method.
writeCharacters
method via regular Writer
interface.
XMLEventReader2
.
XMLStreamReader2
.
XMLStreamWriter2
.
XMLEventWriter
(instead of more generic
text output methods), so that we can verify (if necessary) that
this character output type is legal in this context.
XMLEventWriter
implementation
(instead of the version
that takes no argument), so that we can verify it does match the
start element, if necessary
XMLEventWriter
(instead of the version
that takes no argument), so that we can verify it does match the
start element if necessary.
XMLEventWriter
implementation
(instead of the version
that takes no argument), so that we can verify it does match the
start element, if necessary
BaseNsStreamWriter.writeEndElement()
, but never allows implicit
creation of empty elements.
NonNsStreamWriter.writeEndElement()
, but never allows implicit
creation of empty elements.
XMLStreamWriter.writeEndElement()
, but that will always
write the full end element, instead of empty element.
XmlWriter.writeRaw(java.lang.String, int, int)
, but caller guarantees that the contents
additionally are known to be in 7-bit ascii range.
XMLEventWriter
implementation, to use when
writing a start element, and possibly its attributes and namespace
declarations.
XmlWriter.writeAttribute(String,String,char[],int,int)
but where is known not to require escaping.
XmlWriter.writeAttribute(String,String,char[],int,int)
but where is known not to require escaping.
XmlWriter.writeAttribute(String,String,char[],int,int)
but where is known not to require escaping.
XmlWriter.writeRaw(java.lang.String, int, int)
, but caller guarantees that the contents
additionally are known to be in 7-bit ascii range, and also
passes an encoder object that will encode values only when
being handed a buffer to append to.
XmlWriter.writeRaw(java.lang.String, int, int)
, but caller guarantees that the contents
additionally are known to be in 7-bit ascii range, and also
passes an encoder object that will encode values only when
being handed a buffer to append to.
XMLStreamWriter
interface.XMLEventFactory
to be used with
Woodstox.Stax2EventReaderImpl
.XMLStreamException
Wstx uses.StreamScanner
, and its sub-classes)
to encapsulate input buffer portion of the class.Location
, used by Wstx readers.XMLInputFactory
.IOException
s; needed when StAX does not expose
underlying I/O exceptions via its methods.XMLStreamException
; this generally
happens when doing lazy parsing.XMLOutputFactory
for Wstx.XMLOutputFactory
.XMLEvent2
with method(s)
that are missing from it; specifically linkage that allows using
a stream/event writer for outputting.XMLEventFactory
; especially ones for creating actual
well-behaving DOCTYPE events.XMLEventReader
, based on findings on trying to
implement Stax API v1.0.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.XMLInputFactory
to add
missing functionality.XMLReporter
to allow for better access to
information about the actual problem.Location
that adds accessor to retrieve nested
location information.XMLStreamReader
.XMLStreamWriter
,
as well as to configure individual instances.XMLStreamException
, to be used for
indicating fatal validation problems (when in mode in which exceptions
are to be thrown).XMLValidationSchema
instances.XMLStreamReader
and
XMLStreamWriter
instances can call to validate
xml documents.XmlWriter
to look like a Writer.XMLStreamProperties.XSP_IMPLEMENTATION_NAME
) property.
XMLStreamProperties.XSP_SUPPORT_XMLID
.
XMLStreamProperties.XSP_SUPPORT_XMLID
.
XMLStreamProperties.XSP_SUPPORT_XMLID
.
XMLInputFactory.IS_NAMESPACE_AWARE
) or not
XMLInputFactory.IS_COALESCING
) or not
TypedXMLStreamException
,
TypedXMLStreamException
,
TypedXMLStreamException
,
ReaderConfig._hasConfigFlag(int)
, but that will only
return true if in addition to being set, flag has been explicitly
modified (i.e.
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |