|
|||||||||
PREV NEXT | FRAMES NO FRAMES |
EncodingXmlWriter
used when output
is to be encoded using 7-bit ascii (US-ASCII) encoding.ValidationContext
.WstxInputSource
implementations Woodstox includes need.XMLStreamWriter
implementations Woodstox has.XMLStreamReader2
that implements non-DTD
aware parts of XML handling (plus some minimal support for parsing
DOCTYPE declaration and skipping internal DTD subset if necessary).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.
StartElement
implementation used when directly creating
events from a stream reader.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.
XMLEventAllocator
, to be
used with Woodstox' event reader.XMLStreamReader
.XMLStreamWriter
interface.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
.NamespaceContext
(and BaseNsContext
)
implementation that is usually used in
non-namespace-aware mode.StreamScanner.loadMore()
.
XMLInputFactory
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.
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.
InputElementStack
DTDInfo
, method can just
return this
.
DTDInfo
, method can just
return this
.
SimpleOutputElement.getPrefix()
, but one that will not accept
the default namespace, only an explicit one.
XMLStreamReader.getProperty(java.lang.String)
instead
InputElementStack
instance that "owns" this
attribute collector;
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.
InputElementStack
InputElementStack
DTDInfo.getProcessedDTD()
, but type-safe.
DOMWrappingReader.getText()
, except
that it just uses provided Writer to write all textual content.
BasicStreamReader.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
, Woodstox doesn't currently need
to.
XMLEventReader.hasNext()
, except that it can
throw a XMLStreamException
.
WstxInputSource
to allow
reading input from various sources.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.
XMLOutputFactory.isPropertySupported(java.lang.String)
, used
to determine whether a property is supported by the Writer
instance.
JdkImpl
.java.util.LinkedHashMap
.NameKeySet
suitable for storing large number
of entries; basically anything above trivially small sets (4 or less).ThreadLocal
.
DTDValidatorBase.mAttrSpecs
; needed to store in case type information
is requested later on.
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.mBuckets.length - 1
, when mBuckets.length is
a power of two.
XMLOutputFactory
API: basically
just the cursor-based iteration, and classes it needs.ContentSpec
objects, when they get rewritten (when their ContentSpec.rewrite()
gets called).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.
BasicStreamReader.mCurrToken
is already populated.
NonNsInputElementStack.mElements
that are valid.
NsInputElementStack.mElements
that are valid (ie depth
multiplied by 4)
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.
InputElementStack
used when operating in
non-namespace-aware, non validating mode.XMLStreamWriter
used when namespace support
is not enabled.InputElementStack
used when operating in
namespace-aware mode.CompactStartElement
to output all 'local' namespace declarations active in current
namespace scope, if any.
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).
Property of type Map
, that defines explicit set of
internal (generic) entities that will define of override any entities
defined in internal or external subsets; except for the 5 pre-defined
entities (lt, gt, amp, apos, quot). Can be used to explicitly define
entites that would normally come from a DTD.
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.
Whether white space in attribute values should be normalized as specified by XML specs or not.
Turning this option may help performance if attributes generally have non-normalized white space; otherwise effect is negligible.
Whether non-standard linefeeds (\r, \r\n) need to be converted to standard ones (\n) or not, as per XML specs.
Turning this option off may help performance when processing content that has non-standard linefeeds (Mac, Windows); otherwise effect is negligible.
WstxOutputProperties.P_OUTPUT_VALIDATE_CONTENT
is enabled, instead of
reporting an error, writer will try to fix the problem.
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.
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
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.
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.
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.
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.Stax2ReferentialResult
, which refers
to the specific file.Stax2ReferentialSource
, which refers
to the specific file.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.Validatable.validateAgainst(org.codehaus.stax2.validation.XMLValidationSchema)
was called earlier.
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.
TextBuffer.contentsAsString()
, since it's not guaranteed that resulting
String is cached.
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.
XMLStreamReader
that builds on
BasicStreamReader
, but adds full DTD-handling, including
DTD validationXMLValidator
instances.EntityDecl
instance.DefaultEventAllocator
to get double-indirection necessary for constructing start element
events.
Namespace
.NotationDeclaration
; basically
just wraps the internal notation declaration object woodstox useswriteRaw
method via regular Writer
interface.
writeRaw
method.
writeCharacters
method via regular Writer
interface.
WstxEventWriter
(instead of
more generic
text output methods), so that we can verify (if necessary) that
this character output type is legal in this context.
WstxEventWriter
(instead of the version
that takes no argument), so that we can verify it does match the
start element, if necessary
WstxEventWriter
(instead of the version
that takes no argument), so that we can verify it does match the
start element, if necessary
WstxEventWriter
(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.
WstxEventWriter
, to use when
writing a start element, and possibly its attributes and namespace
declarations.
XMLEventFactory
to be used with
Woodstox.XMLEventReader
, built on top of
BasicStreamReader
(using composition).XMLEventWriter
.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
(which currently means 'nothing'...)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
.
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |