All Classes and Interfaces
Class
Description
This exception will be thrown when the schema parsing is aborted
after all the errors are reported through GrammarReaderController.
Parses XML Schema date/time related types into a structure.
Base implementation for various Verifier implementations.
exposes the low-level validation engine interface.
A state that can have <anyAttribute > element must implement this interface.
used to parse <anyAttribute > element.
used to parse <any > element.
special Token that matchs any element.
a NameClass that matches any name.
place holder for <anyOtherElement> of RELAX.
parses <anyOtherElement> state.
IslandVerifier that validates <anyOtherElement /> of RELAX.
base implementation of AnyAttributeState and AnyElementState.
"anyURI" type.
'attPool' of RELAX module.
parses <ref role="..." />.
parses <attPool> element.
global attribute declaration.
Attribute declaration.
Feeds AttributeToken to the expression and obtains the residual (content model).
attribute group declaration.
parses <attributeGroup /> element.
removes all unnecessary expressions and
creates an expression that consists of required attributes and choices only.
Creates an expression whose AttributeExp is completely replaced by nullSet.
special AttributeToken that memorizes
AttributeExp that fails to
validate itself.Creates an expression whose AttributeExp is completely replaced by epsilon.
parses <attribute> element.
parses <attribute> pattern.
parses <attribute> pattern.
used to parse <attribute > element.
represents attribute and its value.
Attribute wildcard property of the schema component.
Processes the attribtue wildcard according to the spec.
Schema component with
AttributeWildcard"base64Binary" type.
DateTimeValueType object that can hold all lexically valid dateTime value.
ITimeDurationValueType implementation that can hold all lexically legal
timeDuration value.
base implementation for "hexBinary" and "base64Binary" types.
Base implementation for those expression which has two child expressions.
value type of "base64Binary" and "hexBinary" type.
Boyer-Moore searcher.
"boolean" type.
base class for atomic built-in types; those types which can be used by itself
(int,uriReference,string, etc) .
RELAX NG built-in datatypes.
"byte" type.
Formats a
Calendar object to a String.Parses XML Schema date/time related types into
Calendar.state that has no children.
A|B.
Union of two NameClasses.
state that creates ChoiceExp.
common part of <tag> and <attPool>.
creates "combined child content expression" and gathers "elements of concern"
and its "attribute-pruned" content model.
Comparable datatype.
RELAX NG DTD compatibility datatype library.
parses <attribute> pattern.
Accept that is used when more than one pattern can be applicable to the current context.
base implementation of ComplexAcceptor.
used to parse restriction/extension element as a child of complexContent element.
parses <complexContent> element.
used to parse <complexType> element.
ComplexType definition.
base class for types that union/list/atomic.
<concur> pattern of TREX.
parses <concur> pattern.
Constant values related to JARV.
Adapt SAX2 ContentHandler as a SAX1 DocumentHandler.
base implementation for SimpleAcceptor and ComplexAcceptor
Non-recursive ReferenceExpRemover with a cache.
dummy implementation of ValidationContextProvider.
Internal view of GrammarReaderController.
Datatype interface that supports Java databinding.
Expression that matchs characters of the particular
Datatype.parses <param> element inside <data> element.
parses <data> pattern.
parses <data> pattern.
DataTypeBuilder implementation.
Datatype object factory.
generates an text value that matchs to a datatype.
default implementation of DataTypeGenerator.
DatatypeLibrary implementation for Sun XML Datatypes Library.
reference to
Datatypethis class is used to parse foreign datatype vocabulary.
a map from namespace URI to DataTypeVocabulary
Base implementation of facet-restricted datatype
base class for facets which constrains lexical space of data
base class for facets which constrain value space.
base implementation of dateTime and dateTime-truncated types.
utility functions that creates date/time related objects.
"dateTime" type.
"date" type.
makes sure that no two AttributeExps have the same attribute name as their target.
GrammarReaderController that prints all errors and warnings.
Implementation of ElementDecl interface by MSV grammar model.
used to abort the check.
Default implementation of Datatype
parses <define> declaration.
parses <define> declaration.
parses <define> declaration.
<difference> name class.
base interface of types to which length-related facets are applicable.
Used to parse merged grammars.
parses <div> element under <module> element.
DocumentBuilderFactory implementation that supports validation.
DocumentBuilder implementation that supports validation.
Represents a kind of "constraint" over XML document.
SAX DocumentHandler event interceptor.
builds DOM from SAX2 event stream.
Decorates DOM with missing information so that it will be nicely serialized.
A GrammarReaderController2 may already have a DOM element for an imported schema.
implementation class for an LSInput where the only data source is an existing DOM element.
visits all DOM elements in the depth-first order (in-order).
"double" type.
command line Verifier.
command line driver.
converts any supported languages into the equivalent RELAX NG grammar.
Command line argument error.
acts as a function closure to validate a document.
validates a document by using divide & validate framework.
All DTD parsing events are signaled through this interface.
do-nothing implementation of DTDEventHandler.
This implements parsing of XML 1.0 DTDs.
constructs
TREXGrammar object that exactly matches to
the parsed DTD."duration" type.
collects all distinct element declaration in the grammar.
Element declaration.
used to parse <element > element without ref attribute.
Element declaration.
<element> pattern of TREX.
parses <ref label="..." /> element.
used to parse <element > element with ref attribute.
ElementRule declaration of RELAX.
Base implementation for ElementRuleWithHedgeState and ElementRuleWithTypeState.
Set of ElementRule objects that share the label name.
parses <elementRule> without 'type' attribute.
parses <elementRule> with 'type' attribute.
Collects "elements of concern".
parses <element> pattern.
parses <element> pattern.
a token that represents an XML element.
A schema in a DOM Element.
'emptyString' type of RELAX.
Base class for entity declarations as used by the parser.
"ENTITY" type.
"enumeration" facets validator.
Dummy
DatatypeLibrary implementation which is used
to recover from "unknown datatype library" error.wraps ISORELAX ErrorHandler by VerificationErrorHandler interface.
default implementation of ErrorHandler.
Instances of this class is attached to
ValidityViolation to
provide detailed information about the error.Bad attribute.
Bad tag name.
Bad text.
Base class for element related errors.
This error occurs when MSV sees an end tag unexpectedly.
Missing attribute.
A dummy datatype that can be used to recover from errors.
collects all string literals appeared in the text.
exportable Expression.
creates Expression that validates exported attPool.
the purpose of this function object is to make sure
that the expression does not contain references to modules
other than one specified by this variable.
Primitive of the tree regular expression.
Acceptor implementation.clones an expression.
Base class for "finding" something from an expression.
interface that must be implemented by the parent state of ExpressionState.
Creates a new Expression by combining existing expressions.
expression cache by closed hash.
creates a string representation of the expression.
Base implementation for those states who read tags representing an expression.
Visitor interface for Expression and its derived types.
ExpressionVisitor that returns boolean.
ExpressionVisitor that returns Expression object.
ExpressionVisitor that returns void.
Visits all reachable expressions but do nothing.
State that parses Expression which contains other expressions.
Base implementation for those states who cannot have any children.
place holder for imported attributes declaration.
place holder for imported element declaration.
state that reads facets.
Interface implemented by the parent state of FacetState.
base implementation of RELAXFactoryImpl and TREXFactoryImpl
wrapper exception so that we can throw it from the GrammarReaderController.
represents one field of an identity constraint.
XPath matcher that tests one field of a key.
Coordinator of FieldMatcher.
"final" component.
base class of FloatType and DoubleType
"float" type.
feeds SAX events to two ContentHandlers.
'fractionDigits' facet.
"gDay" type.
generates an XML DOM instance that conforms to the given schema.
set of options that controls generation behavior.
State that parses global declarations.
"gMonthDay" type.
"gMonth" type.
base interface of the "grammar".
loads any supported grammar (except XML DTD)
by automatically detecting the schema language.
wrapper exception so that we can throw it from the GrammarReaderController.
base implementation of grammar readers that read grammar from SAX2 stream.
namespace prefix to URI conversion map.
Event notification interface for controlling grammar parsing process.
parses <grammar> element.
parses <grammar> element.
parses <grammar> element.
Converter from AGM to the XML representation.
model group declaration.
used to parse <group> element.
"gYearMonth" type.
"gYear" type.
parses <hedgeRef label="..." /> element.
Base implementation for HedgeRuleState and TopLevelState.
hedgeRule of RELAX module.
parses <hedgeRule> element
this class is used as the base class of TopLevelState
"hexBinary" type.
makes sure that ID/IDREF are not abused.
Interface as value type of DateTimeType
checks the compatibility of RELAX NG grammar with the ID/IDREF feature.
Verifier with XML Schema-related enforcement.
Deprecated.
ValidationContextProvider that supports limited ID/IDREF implementation.
Wraps
IDContextProvider so that it can be used
where IDContextProvider2 is expected.represents an identity constraint.
used to parse <unique>,<key>, and <keyref> element.
very limited 'IDREF' type of XML Schema Part 2.
very limited 'ID' type of XML Schema Part 2.
Default implementation of GrammarReaderController.
do-nothing implementation of ErrorHandler.
state that ignores the entire subtree.
used to parse <import> element.
parses <include> element of RELAX Namespace.
<include> element as an immediate child of <grammar> element.
parses <include> element as a child of <grammar> element.
parses <include> element of RELAX Core.
<include> element in the pattern.
used to parse <include> element.
parses <element> element.
parses <tag> element inlined in <elementRule>
This is how the parser talks to its input entities, of all kinds.
base class for types derived from integer.
"integer" type.
Value object of "integer" type.
parses <interface> element and <div> in interface.
parses <interface> element and <div> in interface.
<interleave> pattern of TREX, or <all> particle of XML Schema.
state that creates an InterleaveExp.
RegExpFactory by the internal copy of Xerces."int" type.
base implementation of IslandSchema for MSV.
replaces all ExternalElementExp and ExternalAttributeExp
by actual definitions.
interface as a value type of TimeDurationType
Interface of verifier.
RegExpFactory by a copy of Xerces in Sun's JDK 5.0.key constraint.
keyref constraint.
represents multi-field keys.
base implementation of HedgeRefState and ElementRefState.
"language" type.
Special name class implementation used for the wild card of the "lax" mode.
Lazy XSTypeIncubator
"length", "minLength", and "maxLength" facet validator.
light-weight stack implementation.
<list> of RELAX NG.
state that parses <list> element of XSD.
state that parses <list> pattern of RELAX NG.
List type.
value object of ListType.
formats messages by using a resource file.
formats messages by using a resource file.
localizes messages
formats messages by using a resource file.
a NameClass that accepts any tag name as long as its local part is specified name.
"long" type.
An instance of this class has ranges captured in matching.
Base abstract implementation of XPath matcher.
Base implementation of Matcher coordinator.
'maxExclusive' facet
'maxInclusive' facet
'maxLength' facet
This class provides support for multi-language string lookup, as needed
to localize messages from applications supporting multiple languages
at the same time.
'minExclusive' facet
'minInclusive' facet
'minLength' facet
<mixed> of RELAX.
parses <mixed> element.
parses <mixed> pattern.
Used to parse module.
parses <module> element.
An utility class that
reads multiple XML Schema documents and combines them into one schema object.
validator of (namespaceURI,localPart) pair.
common interface of AttributeExp and ElementExp.
Base implementation for ElementState and AttributeState
This class collects one name class and patterns
parses <anyName> name class.
parses <choice> name class.
Computes if two name classes collide or not.
Abstract implementation of a function
parses <difference> name class.
parses <name> name class.
parses <not> name class.
parses <nsName> name class.
interface that must be implemented by the parent state of NameClassState.
Minimizes a name class.
Base implementation for NameClass primitives
Visitor interface for NameClass.
parses name class that has child name classes
Base implementation for those states who cannot have any child name class.
Visits NameClass and writes its XML representation.
generates a namespaceURI/localName pair that satisfies given
NameClassNameClass that matchs any names in a particular namespace.
parses <namespace> element of RELAX Namespace.
"Name" type.
"NCName" type.
"negativeInteger" type.
parses <anyName> name class.
Parsing state for <anyName>
Parsing state for <nsName>
"NMTOKEN" type.
'none' datatype of RELAX.
removes "none" type of RELAX from AGM.
"nonNegativeInteger" type.
"nonPositiveInteger" type.
"normalizedString" type.
NameClass that acts a not operator.
"decimal" type.
Used to mark a occurrence constraint which cannot
be easily represented by primitive expressions.
A+.
parses <oneOrMore> pattern.
this object will be added to Expression.verifierTag
to speed up typical validation.
parses <optional> pattern.
Base class for application-specific AGM annotation.
A regular expression parser for the XML Shema.
Base implementation of XPath matching engine.
"pattern" facet validator
"pattern" is a constraint facet which is applied against lexical space.
Visits Expression and writes it as RELAX NG.
"positiveInteger" type.
computes the possible names.
Delegates all methods to the base type.
"QName" type.
value object of QName.
creates random integer.
uniform distribution of [0,x).
Base class of "(max|min)(In|Ex)clusive" facet validator
This class represents a character class such as [a-z] or a period.
state that parses redefinable declaration.
declaration that can be redefined by using <redefine> element.
used to parse <redefine> element.
DocumentDeclaration implementation
Grammar object can be shared among multiple threads, but this object
cannot be shared.Container of ReferenceExp.
Reference to the other expression.
removes all ReferenceExp from AGM.
parses <ref> pattern.
parses <ref> pattern.
A Regular Expression Parser.
A regular expression matching engine using Non-deterministic Finite Automaton (NFA).
VerifierFactory implementation of RELAX Core.
reads RELAX-Namespace-extended RELAX Core.
reads RELAX module (classic RELAX module; no namespace extension)
by SAX2 and constructs abstract grammar model.
Visitor interface for RELAX expressions.
RELAX version of
ExpressionVisitorBoolean.RELAX version of
ExpressionVisitorExpressionRELAX Version of
ExpressionVisitorVoid"Grammar" of RELAX Namespace.
IslandSchema implementation for RELXA module.
"Module" of RELAX Core.
reads RELAX NG grammar with DTD compatibility annotation
and constructs abstract grammar model.
creates various State object, which in turn parses grammar.
VerifierFactory implementation of RELAX NG.
Grammar for RELAX NG (with DTD compatibility annotation).
reads RELAX NG grammar from SAX2 and constructs abstract grammar model.
information necessary to correctly parse pattern definitions.
creates various State object, which in turn parses grammar.
converts any Grammar into RELAX NG XML representation through SAX1 events.
parses RELAX Namespace XML and constructs a SchemaProvider.
reads RELAX grammar/module by SAX2 and constructs abstract grammar model.
creates various State object, which in turn parses grammar.
ErrorHandler that reports all errors and warnings.computes regular expression derivative.
This entity resolver class provides a number of utilities which can help
managment of external parsed entities in XML.
Checks RELAX NG contextual restrictions defined in the section 7.
state that parses <restriction> element.
invokes State object that parses the document element.
invokes State object that parses the document element.
parses the root state of a grammar included as a pattern.
used to parse root of schema document.
parses root state of a merged grammar.
invokes State object that parses the document element.
invokes State object that parses the document element.
invokes State object that parses the document element.
RootIncludedSchemaState + final wrap up.
Acceptor that is used to validate root node of the island.
makes sure that the expression does not run away.
produces SAX2 event from a DOM tree.
SAXParserFactory implementation that supports validation.
SAXParser implementation that supports validation.
This class is used to wrap SAXException by RuntimeException.
base implementation of RELAXFactoryImpl and TREXFactoryImpl
used to parse <schema> element of included schema.
removes "xsi:schemaLocation" from AGM.
implementation of SchemaProvider by using RELAX Grammar.
used to parse <schema> element.
XPath matcher that tests the selector of an identity constraint.
A,B.
state that creates SequenceExp.
an interface that must be implemented by caller to
provide context information that is necessary to
perform conversion from value object to the XML representation.
"short" type.
Acceptor that will be used when only one ElementExp matches
the start tag.
used to parse extension element as a child of <simpleContent> element.
used to parse restriction/extension element as a child of <simpleContent> element.
used to parse <simpleContent> element.
This class implements a special purpose hashtable.
Hashtable collision list.
a NameClass that accepts only one fixed name.
base interface of the most of parsing states.
Simple type declaration.
State that parses <simpleType> element and its children.
simple "ur-type" type.
ElementExp that is used for <any processContents="skip"/>.
parses <start> declaration.
parses <start> element.
immutable start tag information
base interface of 'parsing state'.
calculates how character literals should be treated.
pair of Strings.
special StringToken that acts as a wild card.
reference to String.
parses <string> pattern.
chunk of string.
"string" type.
'tag' of RELAX module.
parses <tag> element.
State that always returns the same expression.
VerifierFactory implementation that automatically detects the schema language.
"time" type.
simple time zone component.
Deprecated.
exists just for the backward serialization compatibility.
This class represents a node in parse tree.
primitive unit of XML instance.
This class represents a node in parse tree.
This class represents a node in parse tree.
This class represents a node in parse tree.
(?(condition)yes-pattern|no-pattern)
(ims-ims: ....
This class represents a node in parse tree.
This class represents a node in parse tree.
This class represents a node in parse tree.
"token" type.
parses <topLevel> element.
'totalDigits' facet.
reads TREX grammar from SAX2 and constructs abstract grammar model.
creates various State object, which in turn parses grammar.
VerifierFactory implementation for TREX.
TREX grammar, which is expressed as <grammar> element.
reads TREX grammar from SAX2 and constructs abstract grammar model.
creates various State object, which in turn parses grammar.
Dummy DataTypeVocabulary for better error recovery.
IslandSchema implementation for TREX pattern.
reads extended-TREX grammar (extended by RELAX Namespace)
and constructs IslandSchema.
IslandVerifier for RELAX Core and TREX.
makes sure that there is no sequenced string.
Receives notification of the typed content of the document.
ElementPattern with type.
reads <element> element with 'label' annotation.
assign types to the incoming SAX2 events and reports them to
the application handler through TypedContentHandler.
reads TREX grammar with 'label' annotation.
derives a new type by adding facets.
State can implement this method to be notified by DataType vocabulary
about the result of parsing.
Base implementation for those states which produce a type object
as its parsing result.
State which has at most one TypeState as its child.
Base implementation for those expression who has one child expresison.
Unicode-related utility functions.
State that parses <union> element and its children.
union type.
unique constraint.
"unsignedByte" type.
"unsignedInt" type.
"unsignedLong" type.
"unsignedShort" type.
date/time-related utility functions/variables.
Collection of utility methods.
Exception that signals error was fatal and recovery was not possible.
Contains information about where and how validity violation was happened.
Expression that matchs a particular value of a
Datatype.parses <value> pattern.
SAX ContentHandler that verifies incoming SAX event stream.
SAX XMLFilter that verifies incoming SAX event stream.
Verifier implementation.
whiteSpace facet validator
processes white space normalization
Catch error messages and resolve schema locations.
A utility class that reads all the schemas from a WSDL.
RegExpFactory by Xerces.Methods in this class are used to determine whether characters may
appear in certain roles in XML documents.
Methods in this class are used to determine whether characters may
appear in certain roles in XML documents.
This class contains static methods used to determine whether identifiers
may appear in certain roles in XML documents.
This class contains static methods used to determine whether identifiers
may appear in certain roles in XML documents.
This handles several XML-related tasks that normal java.io Readers
don't support, inluding use of IETF standard encoding names and
automatic detection of most XML encodings.
set of XML Schema.
parses XML representation of XML Schema and constructs AGM.
creates various State object, which in turn parses grammar.
XML Schema object.
Base class of
ComplexTypeExp and SimpleTypeExp.Helper class that wraps
DocumentHandler and provides utility methods.internal representation of XPath ('aaa/bbb/ccc/ ...
Acceptor implementation for XSREDocDecl.
Publicly accesible interface of W3C XML Schema datatype (simple type).
A wrapper of XSDatatype that serves as an expression
and encapsulates lazy-constructed datatypes.
this object renders the actual datatype object.
this object is used to keep the information about
the dependency between late-bind datatype objects.
base implementaion for XSDatatype interface.
Resolves a datatype name to the corresponding XSDatatypeExp object.
XSD implementation of
DataTypeVocabulary.VerifierFactory implementation for XML Schema.
REDocumentDeclaration that supports several W3C XML Schema
specific semantics.Interface for the type incubator.
Type owner for XML Schema datatypes.
parses <zeroOrMore> pattern.
IDContextProvider2.