|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
WstxInputSource implementations Woodstox includes need.XMLStreamWriter implementations Woodstox has.Location information or not.
StartElement implementation used when directly creating
events from a stream reader.DTD with methods that are
necessary to completely reproduce actual DOCTYPE declaration
constructs in xml documents.DTDSubsetXMLEventAllocator, to be
used with Woodstox' event reader.InputElementStack, specifically the
validating ones (whether
namespace-aware or not).NamespaceContext (and BaseNsContext)
implementation that is usually used in
non-namespace-aware mode.StreamScanner.loadMore().
XMLInputFactoryXMLStreamReader that builds on
WstxStreamReader, but adds full DTD-handling, including
DTD validationSymbolTable.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.
DTDInfo, method can just
return this.
SimpleOutputElement.getPrefix(), but one that will not accept
the default namespace, only an explicit one.
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.
WstxStreamReader.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.
WstxEventWriter, when it
needs/wants to
do direct output, without calling methods in this class (not often).
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.JdkImpl.java.util.LinkedHashMap.NameKeySet suitable for storing large number
of entries; basically anything above trivially small sets (4 or less).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.XMLOutputFactory API: basically
just the cursor-based iteration, and classes it needs.ContentSpec
objects, when they get rewritten (when their ContentSpec.rewrite()
gets called).ElementValidator.mAttrSpecs.
mAttrMap; generally at least 20%
more than number of attributes (mAttrCount).
mAttrMap array.
WstxStreamReader.getEventType().
BaseStreamWriter.writeStartDocument(), or null if
neither.
mBuckets.length - 1, when mBuckets.length is
a power of two.
NonNsInputElementStack.mElements that are valid.
NsInputElementStack.mElements that are valid (ie depth
multiplied by 4)
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).
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).
XMLResolver, that
will allow overriding of default DTD and external parameter entity
resolution.
XMLResolver, that
will allow overriding of default external general entity
resolution.
WstxOutputProperties.P_OUTPUT_VALIDATE_CONTENT is enabled, instead of
reporting an error, writer will try to fix the problem.
FullDTDReader.parseDirective(), but one that takes care
to properly output dtd contents via DTDWriter
as necessary.
TextBuilder instance.
TextBuilder instance.
StreamScanner.getNext(), but does not advance pointer
in input buffer.
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.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.
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.List (from storage perspective),
but that can be used in multiple ways.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.
DTDReaderProxy.readInternalSubset(com.ctc.wstx.sr.StreamScanner, com.ctc.wstx.io.WstxInputSource, com.ctc.wstx.api.ReaderConfig), in that it skims
through structure of internal subset, but without doing any sort
of validation, or parsing of contents.
FullDTDReaderProxy.readInternalSubset(com.ctc.wstx.sr.StreamScanner, com.ctc.wstx.io.WstxInputSource, com.ctc.wstx.api.ReaderConfig), in that it skims
through structure of internal subset, but without doing any sort
of validation, or parsing of contents.
MinimalDTDReaderProxy.readInternalSubset(com.ctc.wstx.sr.StreamScanner, com.ctc.wstx.io.WstxInputSource, com.ctc.wstx.api.ReaderConfig), in that it skims
through structure of internal subset, but without doing any sort
of validation, or parsing of contents.
WstxInputSource from it.
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.InputProblemReporter.throwParseError(String), but specifically defines
location where the error happened.
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.
NonNsInputElementStack used when operating in
non-namespace-aware mode but validating contents against DTDNsInputElementStack that adds basic support for
(DTD-based) validation of XML documents.ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to let the attribute do necessary normalization and/or validation
for the value.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
ElementValidator
to ask attribute to verify that the default it has (if any) is
valid for such type.
EntityDecl instance.Namespace.NotationDeclaration; basically
just wraps the internal notation declaration object woodstox usesXMLEventFactory to be used with
Woodstox.XMLEventReader, built on top of
WstxStreamReader (using composition).XMLEventWriter.XMLStreamException
Wstx uses.IOExceptions; needed when StAX does not expose
underlying I/O exceptions via its methods.StreamScanner, and its sub-classes)
to encapsulate input buffer portion of the class.Location, used by Wstx readers.XMLInputFactory.XMLStreamException; this generally
happens when doing lazy parsing.XMLOutputFactory for Wstx.XMLOutputFactory.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).DefaultEventAllocator
to get double-indirection necessary for constructing start element
events.
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.
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.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||