All Classes and Interfaces
Class
Description
This is the base class of all date/time datatype validators.
This is the base class of all DOM parsers.
This is the base class of all SAX parsers.
This is the base class for all XML document parsers.
Represent the schema type "anySimpleType"
Represent the schema type "anyURI"
A simple ASCII byte reader.
Deprecated.
Deprecated.
AttributeMap inherits from NamedNodeMapImpl and extends it to deal with the
specifics of storing attributes.
Attribute PSV infoset augmentations implementation.
Attribute represents an XML-style attribute of an
Element.
This class represents a single attribute.
AttrNSImpl inherits from AttrImpl and adds namespace support.
This class provides an implementation for Augmentations interface.
This class provides encode/decode for RFC 2045 Base64 as
defined by RFC 2045, N.
Represent the schema type "base64Binary"
the factory to create/return built-in schema DVs and create user-defined DVs
the base factory to create/return built-in schema DVs and create user-defined DVs
A very basic parser configuration.
Boyer-Moore searcher.
Represent the schema type "boolean"
Implementation of
org.apache.xerces.xs.datatypes.ByteList.A parser pool that enables caching of grammars.
Shadowed grammar pool.
Synchronized grammar pool.
XML provides the CDATA markup to allow a region of text in which
most of the XML delimiter recognition does not take place.
CharacterData is an abstract Node that can carry character data as its
Value.
ChildNode inherits from NodeImpl and adds the capability of being a child by
having references to its previous and next siblings.
Content model any node.
Content model Bin-Op node.
This class constructs content models for a given grammar.
Content model leaf node.
A content model node.
This class is a very simple bitset class.
Content model Uni-Op node.
Represents an XML (or HTML) comment.
An extension of ValidationState which can be configured to turn
off checking for ID/IDREF errors and unparsed entity errors.
Commonly used constants.
The Document interface represents the entire HTML or XML document.
The DOMImplementation class is description of a particular
implementation of the Document Object Model.
Base class for datatype exceptions.
Factory that creates new
javax.xml.datatype Objects that map XML to/from Java Objects.Used to format JAXP 1.3 Datatype API error messages using a specified locale.
The interface that a DTD datatype must implement.
Validator for datatype (W3C Schema datatypes)
Validator for <dateTime> datatype (W3C Schema Datatypes)
Validator for <gDay> datatype (W3C Schema datatypes)
Represent the schema type "decimal"
This class implements the DOM's NodeList behavior for
Element.getElementsByTagName()
Default error handler.
A
NamespaceContext which only
contains bindings for the xml and xmlns prefixes.The
Text interface inherits from CharacterData
and represents the textual content (termed character data in XML) of an
Element or Attr.Attribute represents an XML-style attribute of an
Element.
DeferredAttrNSImpl is to AttrNSImpl, what DeferredAttrImpl is to
AttrImpl.
XML provides the CDATA markup to allow a region of text in which
most of the XML delimiter recognition does not take place.
Represents an XML (or HTML) comment.
The Document interface represents the entire HTML or XML document.
This class represents a Document Type declaraction in
the document itself, not a Document Type Definition (DTD).
This DOMImplementation class is description of a particular
implementation of the Document Object Model.
NON-DOM CLASS: Describe one of the Elements (and its associated
Attributes) defined in this Document Type.
Elements represent most of the "markup" and structure of the
document.
DeferredElementNSImpl is to ElementNSImpl, what DeferredElementImpl is to
ElementImpl.
Entity nodes hold the reference data for an XML Entity -- either
parsed or unparsed.
EntityReference models the XML &entityname; syntax, when used for
entities defined by the DOM.
An interface for deferred node object.
Notations are how the Document Type Description (DTD) records hints
about the format of an XML "unparsed entity" -- in other words,
non-XML data bound to this document type, which some applications
may wish to consult when manipulating the document.
Processing Instructions (PIs) permit documents to carry
processor-specific information alongside their actual content.
Text nodes hold the non-markup, non-Entity content of
an Element or Attribute.
DFAContentModel is the derivative of ContentModel that does
all of the non-trivial element content validation.
DocumentFragment is a "lightweight" or "minimal" Document
object.
The Document interface represents the entire HTML or XML document.
This class represents a Document Type declaraction in
the document itself, not a Document Type Definition (DTD).
Deprecated.
Xerces implementation of DOMConfiguration that maintains a table of recognized parameters.
This class wraps DOM entity resolver to XNI entity resolver.
This class handles DOM errors .
DOMErrorImpl is an implementation that describes an error.The DOMImplementation class is description of a particular
implementation of the Document Object Model.
This class implements the DOM Level 3 Core interface DOMImplementationList.
Supply one the right implementation, based upon requested features.
This Class
DOMInputImpl represents a single input source for an XML entity.An
XMLInputSource analogue to javax.xml.transform.dom.DOMSource.DOMLocatorImpl is an implementaion that describes a location (e.g.Used to format DOM error messages, using the system locale.
This class adds implementation for normalizeDocument method.
This class represents an output destination for data.
This is the main Xerces DOM parser class.
This is Xerces DOM Builder class.
DOM Level 3
This class implements the DOM Level 3 Core interface DOMStringList.
Some useful utility methods.
Allows to retrieve
XSImplementation, DOM Level 3 Core and LS implementations
and PSVI implementation.Represent the schema type "double"
This is the DTD-only parser configuration.
The factory to create and return DTD types.
the factory to create/return built-in schema DVs and create user-defined DVs
A DTD grammar.
A simple Hashtable implementation that takes a tuple (String, String)
as the key and a int as value.
This very simple class is the skeleton of what the DTDValidator could use
to store various grammars that it gets from the GrammarPool.
Validator for <duration> datatype (W3C Schema Datatypes)
A runtime exception that's thrown if an error happens when the application
tries to get a DV factory instance.
NON-DOM CLASS: Describe one of the Elements (and its associated
Attributes) defined in this Document Type.
Elements represent most of the "markup" and structure of the
document.
ElementNSImpl inherits from ElementImpl and adds namespace support.
Element PSV infoset augmentations implementation.
Location which always returns
-1
and null from its methods.EncodingMap is a convenience class which handles conversions between
IANA encoding names and Java encoding names, and vice versa.
ENTITYDatatypeValidator implements the
DatattypeValidator interface.
Represent the schema type "entity"
Entity nodes hold the reference data for an XML Entity -- either
parsed or unparsed.
EntityReference models the XML &entityname; syntax, when used for
entities defined by the DOM.
This class wraps a SAX entity resolver (EntityResolver2) in an XNI entity resolver.
This class wraps a SAX entity resolver in an XNI entity resolver.
The entity state interface defines methods that must be implemented
by components that store information about entity declarations, as well as by
entity validator that will need to validate attributes of type entity.
Wraps
XMLErrorHandler and make it look like a SAX ErrorHandler.This class wraps a SAX error handler in an XNI error handler.
EventImpl is an implementation of the basic "generic" DOM Level 2 Event
object.
A special factory to create/return built-in schema DVs and create user-defined DVs
that includes anyAtomicType, yearMonthDuration and dayTimeDuration
This interface extends
XMLEntityResolver providing
a method to resolve external subsets for documents which do not
explicitly provide one.Schema identity constraint field.
Field XPath.
Interface for a field activator.
Represent the schema type "float"
the factory to create/return built-in schema DVs and create user-defined DVs
format validation
This class encodes/decodes hexadecimal data
Represent the schema type "hexBinary"
This class represents an input source for an XML resource
retrievable over HTTP.
IDDatatypeValidator - ID represents the ID attribute
type from XML 1.0 Recommendation.
Represent the schema type "ID"
Base class of Schema identity constraint.
IDREFDatatypeValidator - represents the IDREFS
attribute type from XML 1.0 recommendation.
Represent the schema type "IDREF"
An immutable StAX
Location.Represent the schema type "integer"
This is configuration uses a scanner that integrates both scanning of the document
and binding namespaces.
A simple integer based stack.
Datatype exception for invalid facet.
Datatype exception for invalid values.
This interface holds JAXP constant property/attribute names and values.
A read-only XNI wrapper around a JAXP NamespaceContext.
Schema key reference identity constraint.
Reader for the ISO-8859-1 encoding.
For list types: ENTITIES, IDREFS, NMTOKENS.
Represent the schema list types
Wraps
XMLLocator and make it look like a SAX Locator.Contains a list of LSInputs.
Signals that a malformed byte sequence was detected
by a
java.io.Reader that decodes bytes
of a given encoding into characters.An instance of this class has ranges captured in matching.
This interface provides a generic message formatting mechanism and
is useful for producing messages that must be localized and/or formatted
with replacement text.
MixedContentModel is a derivative of the abstract content model base
class that handles the special case of mixed model elements.
Validator for <gMonthDay> datatype (W3C Schema Datatypes)
Validator for <gMonth> datatype (W3C Schema Datatypes)
An implementation of the DOM Level 2
MouseEvent interface.This implementation of NamespaceContext has the ability to maintain multiple
scopes of namespace/prefix bindings.
An implementation of the DOM Level 2
MutationEvent interface.NamedNodeMaps represent collections of Nodes that can be accessed
by name.
Namespace support for XML document handlers.
NMTOKEN datatype validator.
NodeImpl provides the basic structure of a DOM tree.
DefaultNodeIterator implements a NodeIterator, which iterates a
DOM tree in the expected depth first way.
This is the non validating parser configuration.
NOTATIONValidator defines the interface that data type validators must obey.
Notations are how the Document Type Description (DTD) records hints
about the format of an XML "unparsed entity" -- in other words,
non-XML data bound to this document type, which some applications
may wish to consult when manipulating the document.
Contains a list of Objects.
ParentNode inherits from ChildNode and adds the capability of having child
nodes.
This class implements the basic operations for managing parser
configuration features and properties.
Processing Instructions (PIs) permit documents to carry
processor-specific information alongside their actual content.
Attribute namespace implementation; stores PSVI attribute items.
Our own document implementation, which knows how to create an element
with PSVI information.
The DOMImplementation class is description of a particular
implementation of the Document Object Model.
Element namespace implementation; stores PSVI element items.
Represent the schema type "QName" and "NOTATION"
The RangeImpl class implements the org.w3c.dom.range.Range interface.
A regular expression matching engine using Non-deterministic Finite Automaton (NFA).
DOM Revalidation handler adds additional functionality to XMLDocumentHandler
An
XMLInputSource analogue to javax.xml.transform.sax.SAXSource.A light wrapper around a SAX locator.
Used to format SAX error messages using a specified locale.
This is the main Xerces SAX parser class.
This is the implementation specific class for the
javax.xml.parsers.SAXParserFactory.This is the implementation specific class for the
javax.xml.parsers.SAXParser.Extension of SAXParser.
Defines a factory API that enables applications to
the factory to create/return built-in schema 1.0 DVs and create user-defined DVs
This class is to hold all schema component declaration that are declared
within one namespace.
A partial schema for schemas for validating annotations.
This class customizes the behaviour of the util.NamespaceSupport
class in order to easily implement some features that we need for
efficient schema handling.
Collection of symbols used to parse a Schema Grammar.
This configuration enhances Xerces support for the JAXP secure processing feature.
This configuration allows Xerces to behave in a security-conscious manner; that is,
it permits applications to instruct Xerces to limit certain
operations that could be exploited by malicious document authors to cause a denail-of-service
attack when the document is parsed.
This class is a container for parser settings that relate to
security, or more specifically, it is intended to be used to prevent denial-of-service
attacks from being launched against a system running Xerces.
Schema identity constraint selector.
Schema identity constraint selector XPath expression.
Shadowed symbol table.
Contains a list of shorts.
SimpleContentModel is a derivative of the abstract content model base
class that handles a small set of simple content models that are just
way overkill to give the DFA treatment.
An XMLLocator implementation used for schema error reporting.
This symbol table uses SoftReferences to its String entries, which means that table entries
that have no references to them can be garbage collected when memory is needed.
This class is a symbol table entry.
This parser configuration extends the default configuration allowing Xerces to
handle usage scenarios where the names in the XML documents being parsed are mostly
unique by installing a memory sensitive
SymbolTable.This is the "standard" parser configuration.
An
XMLInputSource analogue to javax.xml.transform.stax.StAXSource.A light wrapper around a StAX location.
StringValidator validates that XML content is a W3C string type.
Represent the schema type "string"
Contains a list of Strings.
To store and validate information about substitutionGroup
This class is an unsynchronized hash table primarily used for String
to Object mapping.
This class is a key table entry.
This class is a symbol table implementation that guarantees that
strings used as identifiers are unique references.
This class is a symbol table entry.
Synchronized symbol table.
Text nodes hold the non-markup, non-Entity content of
an Element or Attribute.
Validator for <time> datatype (W3C Schema Datatypes)
This class implements the TreeWalker interface.
All primitive types plus ID/IDREF/ENTITY/INTEGER are derived from this abstract
class.
Reader for UCS-2 and UCS-4 encodings.
An implementation of the DOM Level 2
UIEvent interface.Represent the schema union types
Schema unique or key identity constraint.
A class to represent a Uniform Resource Identifier (URI).
MalformedURIExceptions are thrown in the process of building a URI
or setting fields on a URI when an operation would result in an
invalid URI specification.
A UTF-16 reader.
A UTF-8 reader.
Class to get the information back after content is validated.
ValidationContext has all the information required for the
validation of: id, idref, entity, notation, qname
ValidationManager is a coordinator property for validators in the
pipeline.
Implementation of the ValidationContext interface.
Interface for storing values associated to an identity constraint.
This class defines the version number of the parser.
This class is used for reading resources requested in <include> elements in
XML 1.1 entities, when the parse attribute of the <include> element is "text".
This class is the configuration used to parse XML 1.0 and XML 1.1 documents
and provides support for XInclude.
This is a pipeline component which performs XInclude handling, according to the
W3C specification for XML Inclusions.
XIncludeMessageFormatter provides error messages for the XInclude 1.0 Candidate Recommendation
This is an implementation of NamespaceContext which is intended to be used for
XInclude processing.
This parser configuration includes an
XIncludeHandler in the pipeline
before the schema validator, or as the last component in the pipeline if there is
no schema validator.This class is used for reading resources requested in <include> elements,
when the parse attribute of the <include> element is "text".
This class defines the basic properties of characters in XML 1.1.
An
XMLParserConfiguration implements this interface
in order to indicate that it provides support for XML 1.1.This class is the configuration used to parse XML 1.0 and XML 1.1 documents.
This class is responsible for scanning XML document structure
and content.
This class is the DTD-only parser configuration
used to parse XML 1.0 and XML 1.1 documents.
the factory to create/return built-in XML 1.1 DVs and create user-defined DVs
This class extends XMLDTDProcessor by giving it
the ability to parse XML 1.1 documents correctly.
This class is responsible for scanning the declarations found
in the internal and external subsets of a DTD in an XML document.
This allows the validator to correctlyhandle XML 1.1
documents.
Implements the entity scanner methods in
the context of XML 1.1.
IDDatatypeValidator - ID represents the ID attribute
type from XML 1.1 Recommendation.
IDREFDatatypeValidator - represents the IDREFS
attribute type from XML 1.1 recommendation.
This class performs namespace binding on the startElement and endElement
method calls in accordance with Namespaces in XML 1.1.
NMTOKEN datatype validator for NMTokens from XML 1.1.
This class is the non validating parser configuration
used to parse XML 1.0 and XML 1.1 documents.
The scanner acts as the source for the document
information which is communicated to the document handler.
The DTD validator.
The XMLAttributesImpl class is an implementation of the XMLAttributes
interface which defines a collection of attributes for an element.
The catalog resolver handles the resolution of external
identifiers and URI references through XML catalogs.
This class defines the basic XML character properties.
ContentSpec really exists to aid the parser classes in implementing
access to the grammar.
Provides a means for walking the structure built out of
content spec "nodes".
This class is responsible for scanning the structure and content
of document fragments.
This interface defines an XML "event" dispatching model.
Element stack.
This is a concrete vanilla XML parser class.
This class is responsible for scanning XML document structure
and content.
All information specific to DTD grammars.
The DTD loader.
The DTD processor.
This class is responsible for scanning the declarations found
in the internal and external subsets of a DTD in an XML document.
The DTD validator.
Defines a DTD Validator filter to allow
components to query the DTD validator.
This interface describes the properties of entities--their
physical location and their name.
This class is an implementation of the XMLEntityDescription
interface which describes the properties of an entity.
The entity handler interface defines methods to report information
about the start and end of entities.
The entity manager handles the registration of general and parameter
entities; resolves entities; and starts entities.
Entity information.
External entity.
Internal entity.
Implements the entity scanner methods.
This class is a common element of all parser configurations and is
used to report errors that occur.
Implementation of XMLEventFactory.
This configuration provides a generic way of using
Xerces's grammar caching facilities.
Stores grammars in a pool associated to a specific key.
This class is a grammar pool entry.
This class provides an easy way for a user to preparse grammars
of various types.
A light wrapper around an
XMLLocator.XMLMessageFormatter provides error messages for the XML 1.0 Recommendation and for
the Namespaces Recommendation
This class performs namespace binding on the startElement and endElement
method calls and passes all other methods through to the registered
document handler.
The scanner acts as the source for the document
information which is communicated to the document handler.
The DTD validator.
Base class of all XML-related parsers.
The XMLResourceIdentifierImpl class is an implementation of the
XMLResourceIdentifier interface which defines the location identity
of a resource.
This class is responsible for holding scanning methods common to
scanning the XML document structure and content as well as the DTD
structure and content.
This exception might be thrown by any constraint checking method.
SchemaFactory for XML Schema.This class implements xni.grammars.XMLGrammarLoader.
The XML Schema validator.
A simple vector for
shorts.Stack of XPath matchers for identity constraints.
XMLString is a structure used to pass character arrays.
All internalized xml symbols.
This class scans the version of the document to determine
which scanner to use: XML 1.1 or XML 1.0.
Bare minimum XPath parser.
Axis.
A location path representation for an XPath expression.
Node test.
A location path step comprised of an axis and node test.
XPath exception.
XPath matcher.
This is a pipeline component which extends the XIncludeHandler to perform
XPointer specific processing specified in the W3C XPointerFramework and
element() Scheme Recommendations.
This parser configuration includes an
XPointerHandler in the pipeline
before the schema validator, or as the last component in the pipeline if there is
no schema validator.
Used for scheme specific parsing and evaluation of an XPointer expression.
The XPointerProcessor is responsible for parsing an XPointer
expression and and providing scheme specific resolution of
the document fragment pointed to be the pointer.
Class defining utility/helper methods to support XML Schema 1.0 implementation.
XSAllCM implements XSCMValidator and handles <all>.
This is an implementation of the XSAnnotation schema component.
Class
XSAttributeCheck is used to check the validity of attributes
appearing in the schema document.The XML representation for an attribute declaration
schema component is an <attribute> element information item
The XML representation for an attribute group declaration
schema component is a global <attributeGroup> element information item
The XML representation for an attribute use
schema component is a local <attribute> element information item
Content model Bin-Op node.
Content model leaf node.
A compound content model leaf node which carries occurence information.
Content model Uni-Op node.
Note: State of the content model is stored in the validator
The XML representation for a complexType
schema component is a <complexType> element information item
Constraints shared by traversers and validator
All information specific to XML Schema grammars.
This class is pool that enables caching of XML Schema declaration objects.
DFAContentModel is the implementation of XSCMValidator that does
all of the non-trivial element content validation.
The purpose of this class is to co-ordinate the construction of a
grammar object corresponding to a schema.
The XML representation for an element declaration
schema component is an <element> element information item
XSEmptyCM is a derivative of the abstract content model base class that
handles a content model with no children (elements).
The class used to pass all facets to
XSSimpleType.applyFacets(org.apache.xerces.impl.dv.XSFacets, short, short, org.apache.xerces.impl.dv.ValidationContext).A class used to hold the internal schema grammar set for the current instance
Add a method that return an
XSModel that represents components in
the schema grammars in this pool implementation.A container for grammar pools which only contain schema grammars.
The XML representation for a group declaration
schema component is a global <group> element information item
Implements XSImplementation interface that allows one to retrieve an instance of
XSLoader.An implementation of XSLoader which wraps XMLSchemaLoader.
SchemaMessageProvider implements an XMLMessageProvider that
provides localizable error messages for the W3C XML Schema Language
Store schema model group declaration.
Implements XSModel: a read-only interface that represents an XML Schema,
which could be components from different namespaces.
Contains the map between qnames and XSObject's.
Contains the map between qnames and XSObject's.
The XML representation for a NOTATION declaration
schema component is a global <notation> element information item
Contains a list of XSObjects.
Store schema particle declaration.
This interface
XSSimpleType represents the simple type
definition of schema component and defines methods to query the information
contained.Base class for XSSimpleType wrapper implementations.
The XML representation for a wildcard declaration
schema component is an <any> or <anyAttribute> element information item
Validator for <gYear> datatype (W3C Schema Datatypes)
Validator for <gYearMonth> datatype (W3C Schema Datatypes)