|
|||||||||
| 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.DTDSubsetXMLValidator; the class that
handles DTD-based validation.XMLValidator.NamespaceContext (and BaseNsContext)
implementation that is usually used in
non-namespace-aware mode.StreamScanner.loadMore().
XMLInputFactorySymbolTable.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.
Stax2Results
that an be used to write to in-memory (low-level) data structures,
such as byte and char arrays, StringBuffers and so forth.Stax2Sources
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.Stax2Results
that refer to a resource in such a way, that an efficient
OutputStream or Writer can be constructed.Stax2Sources
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.IOExceptions; 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 | ||||||||