This exception will be thrown when the schema parsing is aborted
after all the errors are reported through GrammarReaderController.
Base implementation for various Verifier implementations.
exposes the low-level validation engine interface.
AnyNameClass accpets any name, as its name suggests.
accepts a name if it is accepted by nc1 or nc2.
accepts a name if it is accepted by nc1 and not by nc2.
checks if this name class accepts given namespace:localName pair.
checks if this name class accepts given namespace:localName pair.
accepts a name if its namespace URI matches to the namespaceURI field.
accepts a name if it is not accepted by the child name class.
checks if this name class accepts given namespace:localName pair.
add a name so that this name will be rejected by the accepts method.
name class that accepts everything.
signals that the document is ambiguous.
Namespace URI of RELAX NG DTD compatibility annotation
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.
Parsing state for <anyName>
place holder for <anyOtherElement> of RELAX.
creates "skelton" of AnyOtherElement.
parses <anyOtherElement> state.
IslandVerifier that validates <anyOtherElement /> of RELAX.
base implementation of AnyAttributeState and AnyElementState.
special expression object that represents "any string".
'attPool' of RELAX module.
parses <ref role="..." />.
map from role name to AttPoolClause object
parses <attPool> element.
information about the attribute that caused the error.
For each entry in an ATTLIST declaration,
this event will be fired.
For each entry in an ATTLIST declaration,
this event will be fired.
global attribute declaration.
name of this attribute declaration.
map from attribute declaration name to AttributeDeclExp object
Feeds AttributeToken to the expression and obtains the residual (content model).
Attribute-free content model
attribute group declaration.
name of this attribute group declaration.
map from attribute group name to AttributeGroupExp object
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.
Creates an expression whose AttributeExp is completely replaced by epsilon.
parses <attribute> element.
parses <attribute> pattern.
parses <attribute> pattern.
used to parse <attribute > element.
optional attribute step that can only appear as the last child.
represents attribute and its value.
Attribute wildcard property of the schema component.
Processes the attribtue wildcard according to the spec.
attribute wildcard as an expression.
computes all possibile names for this name class, and returns
the set of
StringPair
.
receives notification of a string.
Adapt a SAX1 characters event.
Receive notification of character data.
Receive notification of character data.
Traverses the grammar and performs the contextual check.
Returns true if two name classes collide.
Checks the contextual restriction on a name class.
state that has no children.
iterates all child expressions.
Union of two NameClasses.
state that creates ChoiceExp.
Chooses a client locale to use for diagnostics, using the first
language specified in the list that is supported by this parser.
Chooses a client locale to use, using the first language specified in
the list that is supported by this catalog.
constraints over start tag of the element
expression cache by closed hash.
abstract grammar model(AGM): common part.
abstract grammar model(AGM): RELAX stub.
RELAX NG built-in datatype implementation.
abstract grammar model (AGM): TREX extension
and TREX stub.
Abstract grammar model (AGM): TREX label-annotated stub.
Miscellaneous utility classes.
W3C XML Schema grammar model.
reads XML representation of grammar and creates AGM.
interface of Datatype vocabulary reader.
reads XML representation for XML Schema Part.2
reads DTD and constructs AGM.
common parts for parseing RELAX Core/Namespace into AGM.
parses RELAX Core into AGM.
Non-essential schema conformance checks.
shared code between RELAX NG reader and TREX reader.
parses TREX pattern into AGM.
parses RELAX NG into AGM.
parses RELAX NG with DTD compatibility annotation into AGM.
reads TREX grammar with "label
annotation".
parses XML representation of XML Schema into AGM.
abstract grammar model(AGM) for RELAX Namespace.
abstract grammar model(AGM) for RELAXNS-extended RELAX Core.
abstract grammar model(AGM) for RELAXNS-extended TREX.
parses XML representation of RELAX Namespace.
parses XML representation of RELAXNS-extended RELAX Core.
parses XML representation of RELAXNS-extended TREX.
"divide&validate" framework implementation.
scan DTD stream and generates appropriate events.
Contains abstract model for grammar-based schema and
concrete verifier implementation for the abstract schema.
Verifier with XML Schema's identity constraint check.
Implementation of JARV (Java API for RELAX
Verifier).
Type-assignment engine
that can be used by application programs.
VGM implementation by using regular expression derivation algorithm.
RegExp VGM implementation that supports special semantics of XML Schema
This package should be considered as a dity ugly quick-hack.
AGM to RELAX NG converter
creates "combined child content expression" and gathers "elements of concern"
and its "attribute-pruned" content model.
converts the relative URL to the absolute one by using the specified base URL.
Receive notification that a comment has been read.
Receive notification that a comment has been read.
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.
base type of this complex type.
used to parse restriction/extension element as a child of complexContent element.
parses <complexContent> element.
used to parse <complexType> element.
map from simple type name to SimpleTypeExp object
expression that matches to "ur-type" when used as a complex type.
<concur> pattern of TREX.
Connectors in one model group is guaranteed to be the same.
Connectors in one model group is guaranteed to be the same.
Constant values related to JARV.
Adapt SAX2 ContentHandler as a SAX1 DocumentHandler.
content model of this element declaration.
in this mode, element declaration is
one of the terminal symbol of stringnization.
base implementation for SimpleAcceptor and ComplexAcceptor
Non-recursive ReferenceExpRemover with a cache.
object that provides additional information which is necessary
for validating some datatypes
the expression that should be used by the parent acceptor
once if this acceptor is satisfied.
Internal view of GrammarReaderController.
this object receives errors and warnings
creates a new Acceptor that will validate the document element.
creates a new Acceptor that will validate the document element.
creates a new Acceptor that will validate the document element.
creates a state object that parses "attribute","attributeGroup ref", and "anyAttribute".
creates an Acceptor that will accept
the content model of the children of this moment.
creates combined child acceptor and primitive child acceptors (if necessary).
creates combined child acceptor and primitive child acceptors (if necessary).
Obtains a Datatype object from its name.
Creates the expression that corresponds to
the current attribute wildcard specification.
this method must be implemented by the derived class to create
language-default expresion state.
this method must be implemented by the derived class to create
language-default expresion state.
this method must be implemented by the derived class to create
language-default expresion state.
this method must be implemented by the derived class to create
language-default expresion state.
this method must be implemented by the derived class to create
language-default expresion state.
this method must be implemented by the derived class to create
language-default expresion state.
this method must be implemented by the derived class to create
language-default expresion state.
Derives a new type by setting final values.
Creates an incubator so that the caller can add more facets
and derive a new type.
Creates an input source from a given file, autodetecting
the character encoding.
Returns an input source, using the MIME type information and URL
scheme to statically determine the correct character encoding if
possible and otherwise autodetecting it.
Creates an input source from a given URI.
creates a state object that parses "all"/"group ref"/"choice" and "sequence".
creates a State object that will parse the element specified
by tag parameter.
creates a State object that will parse the element specified
by tag parameter.
Expression that matchs characters of the particular Datatype
.
parses <param> element inside <data> element.
data type vocabularies used and defined by this grammar.
this class is used to parse foreign datatype vocabulary.
a map from namespace URI to DataTypeVocabulary
makes sure that no two AttributeExps have the same attribute name as their target.
debug - static field in class com.sun.msv.driver.textui.
Debug GrammarReaderController that prints all errors and warnings.
Implementation of ElementDecl interface by MSV grammar model.
parses <define> declaration.
parses <define> declaration.
parses <define> declaration.
the derivation method used to derive this complex type from the base type.
detects undefined ReferenceExp and reports it as an error.
Used to parse merged grammars.
parses <div> element under <module> element.
DocumentBuilderFactory implementation that supports validation.
Creates a new instance by using the default DocumentBuilderFactory implementation
as the underlying parser.
Creates a new instance by specifying the underlying SAXParserFactory
implementation.
Represents a kind of "constraint" over XML document.
SAX DocumentHandler event interceptor.
a flag that indicates State objects should check duplicate definitions.
builds DOM from SAX2 event stream.
visits all DOM elements in the depth-first order (in-order).
dt - field in class com.sun.msv.grammar.
DataExp datatype object that actually validates text.
Datatype object that is used to test the equality.
All DTD parsing events are signaled through this interface.
use the default SAXParser.
do-nothing implementation of DTDEventHandler.
This implements parsing of XML 1.0 DTDs.
constructs
TREXGrammar
object that exactly matches to
the parsed DTD.
map from attribute declaration name to AttributeDeclExp object
used to parse <element > element without ref attribute.
Base class for element related errors.
<element> pattern of TREX.
parses <ref label="..." /> element.
used to parse <element > element with ref attribute.
ElementRule declaration of RELAX.
Set of ElementRule objects that share the label name.
map from label name to ElementRules object
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.
'emptyString' type of RELAX.
receives notification of the end of an attribute.
this method is called after the start/endAttribute method are called
for all attributes.
Receive notification that the CDATA section finished.
Receive notification that the CDATA section finished.
receives notification that parsing of content model is finished.
receives notification that parsing of content model is finished.
Adapt a SAX1 end document event.
receives notification of the end of a document.
Receive notification of the end of a DTD.
Receive notification of the end of a DTD.
Adapt a SAX1 end element event.
receives notification of the end of an element.
this method is called in endElement method
when the state is about to be removed.
this method is called in endElement method
when the state is about to be removed.
Special expression object that represents epsilon (ε).
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.
'except' clause of RELAX NG.
exp - field in class com.sun.msv.relaxns.grammar.
DeclImpl "meat" of this Rule.
a flag that indicates this elementRule is exported and
therefore accessible from other modules.
a flag that indicates this elementRule is exported and
therefore accessible from other modules.
a flag that indicates this hedgeRule is exported and
therefore accessible from other modules.
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.
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.
creates new expression pool as a child pool of the given parent pool.
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.
entity resolution is delegated to this object.
Receive notification of an external parsed general entity
declaration event.
Receive notification of an external parsed general entity
declaration event.
Receive notification of an external parameter entity declaration
event.
Receive notification of an external parameter entity declaration
event.
computes a combined child content pattern and (,if possible,) its continuation.
computes a combined child content pattern and its continuation, with error recovery.
obtains an DataTypeVocabulary associated to the namespace.
obtains all items in this container.
gets value of the specified attribute.
Gets the attribute wildcard property of this schema component.
tries to obtain a DataType object by resolving obsolete names.
Gets the value of the block constraint.
gets the value of the block constraint.
gets the value of the block constraint.
gets XMLSchemaSchema object that has the given target namespace.
gets the next Java character -- might be part of an XML
text character represented by a surrogate pair, or be
the end of the entity.
returns all child expressions in one array.
Gets a clone of this object.
returns -1; maintaining column numbers hurts performance
gets the pattern that represents the content model of
this element declaration.
Gets a encapsulated datatype object
This method can be called only after all the datatypes are created.
Some of the datatypes are lazily during the back-patching phase.
returns current element type.
returns current element type.
gets current State object.
Gets the encapsulated Datatype object.
Returns the datatypeLibraryFactory.
Returns the handler used to for DTD parsing events.
Returns the name of the encoding in use, else null; the name
returned is in as standard a form as we can get.
Returns the object used to resolve entities
Gets the detailed error information, if any.
Gets the expression after removing all ReferenceExps, until child
AttributeExp or ElementExp.
gets the residual content model.
gets an incubator object that the owner holds.
gets an incubator object that the owner holds.
gets an incubator object that the owner holds.
gets an incubator object that the owner holds.
gets an incubator object that the owner holds.
Gets an InputSource from a string, which contains either
a file name or an URL.
creates an IslandSchemaReader
that can parse the specified language.
gets DataType that validated the last characters.
gets DataType that validated the last characters.
Returns the current line number in this input source
Returns the diagnostic locale.
obtains matched elements.
Get a message localized to the specified locale, using the message ID
and package name if no message is available.
Format a message localized to the specified locale, using the message
ID with its package name if none is available.
Gets the target of the name class.
returns the next name char, or NUL ...
obtains a constraint over tag name.
obtains a constraint over tag name.
obtains a constraint over tag name.
obtains a constraint over tag name.
obtains a constraint over tag name.
obtains a constraint over tag name.
gets a reference to XMLSchemaGrammar object whose target namespace
is the specified one.
gets State object who has submitted this patch job.
gets the "type" object for which this acceptor is working.
gets the "type" object for which this acceptor is working.
gets the parent ElementRules object.
gets a parent TREXGrammar.
gets ExpressionPool object which was used to construct this grammar.
Gets the processing model of the wildcard.
Returns the public ID of this input source, if known
Obtains a
ReferenceExp
that represents the target
pattern block.
gets all the refer who have a reference to this object.
Obtains the parsed grammar object.
Obtains the parsed grammar.
obtains parsed grammar object only if parsing was successful.
obtains parsed grammar object only if parsing was successful.
obtains parsed grammar object only if parsing was successful.
collects satisfied ElementExps.
obtains parsed grammar object as SchemaProvider
only if parsing was successful.
gets how this acceptor handles characters.
Returns the system ID of this input source, if known
Returns the target namespace URI of newly created simple types.
Returns the target namespace URI of newly created simple types.
Returns the target namespace URI of newly created simple types.
Returns the target namespace URI of newly created simple types.
gets top-level expression.
gets the XSDatatypeExp object that represents this simple type.
Gets the type definition.
resolves a type name to Datatype object.
resolves a type name to Datatype object.
State that parses global declarations.
base interface of the "grammar".
RELAX grammar that is currentlt being loaded
loads any supported grammar (except XML DTD)
by automatically detecting the schema language.
base implementation of grammar readers that read grammar from SAX2 stream.
Event notification interface for controlling grammar parsing process.
parses <grammar> element.
parses <grammar> element.
parses <grammar> element.
Converter from AGM to the XML representation.
map from attribute declaration name to AttributeDeclExp object
used to parse <group> element.
makes sure that ID/IDREF are not abused.
Verifier with XML Schema-related enforcement.
ValidationContextProvider that supports limited ID/IDREF implementation.
ValidationContextProvider that supports limited ID/IDREF implementation.
represents an identity constraint.
identity constraints associated to this declaration.
map from identity constraint name to IdentityConstraint object.
used to parse <unique>,<key>, and <keyref> element.
Adapt a SAX1 ignorable whitespace event.
Receive notification of ignorable whitespace in element content.
Receive notification of ignorable whitespace in element content.
whitespace in markup (flagged to app, discardable)
the document handler's ignorableWhitespace() method
is called on all the whitespace found
Default implementation of GrammarReaderController.
do-nothing implementation of ErrorHandler.
state that ignores the entire subtree.
a flag that indicates undeclared attributes should be ignored.
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.
Returns true if this name class is a superset of another name class.
used to parse <include> element.
This error occurs when MSV sees an end tag unexpectedly.
parses <element> element.
parses <tag> element inlined in <elementRule>
This is how the parser talks to its input entities, of all kinds.
parses <interface> element and <div> in interface.
<interleave> pattern of TREX, or <all> particle of XML Schema.
state that creates an InterleaveExp.
Receive notification of a internal general entity declaration event.
Receive notification of a internal general entity declaration event.
Receive notification of a internal parameter entity declaration
event.
Receive notification of a internal parameter entity declaration
event.
Computes the intersection of two name classes.
Checks if a given string is an absolute URI if it is an URI.
checks if this complex type is abstract.
checks if this element declaration is abstract.
checks if this Acceptor is satisifed.
checks if this Acceptor is satisifed
the compatibility property of the annotation feature.
this field is true if the XPath starts with '//' operator.
Returns true if the argument, a UCS-4 character code, is valid in
XML documents.
checks if the result of 'get' method is not the union of all
elements of concern.
the compatibility property of the default attribute feature.
checks if this ReferenceExp is properly defined.
Checks if this type is a derived type of the specified type.
returns true iff there's no more data to consume ...
returns true if this expression accepts empty sequence.
Returns true if this name class represents the same set as the given name class.
Returns true if this element declaration is a global element declaration.
the compatibility property of the ID/IDREF feature.
Returns true if this resolver is ignoring MIME types in the documents
it returns, to work around bugs in how servers have reported the
documents' MIME types.
base implementation of IslandSchema for MSV.
Returns true if the character is an XML "letter".
Returns true iff the specified locale has explicit language support.
Returns true if the value is a legal XML name.
Returns true if the character is allowed to be a non-initial
character in names according to the XML recommendation.
Returns true if the character is allowed to be a non-initial
character in unscoped names according to the rules of the XML
Namespaces proposed recommendation.
This method returns true if the identifier is a "name token" as
defined by the XML Namespaces proposed recommendation.
This method returns true if the identifier is a "name token"
as defined in the XML specification.
Returns true if this name class doesn't accept anything.
Returns true if the value is a legal "qualified" XML name, as defined
in the XML Namespaces proposed recommendation.
Returns true if the character is allowed where XML supports
whitespace characters, false otherwise.
Returns true if the value is a legal "unqualified" XML name, as
defined in the XML Namespaces proposed recommendation.
checks if the document was valid.
checks if the document was valid.
Iterates Map.Entry objects which has the prefix as key and
the namespace URI as value.
returns an Iterator that enumerates XMLSchemaSchema objects
that are defined in this grammar.
iterates all ReferenceExp in this container
Derives a new type by list.
Derives a new type by union.
DataExp can consume this token if its datatype can accept this string
returns true if the given DataExp can consume this token
returns true if the given ElementExp can consume this token
ListExp can consume this token if its pattern accepts this string
returns true if the given ListExp can consume this token
returns true if anyString pattern can consume this token
holds a reference to the assigned type.
Base abstract implementation of XPath matcher.
optional grammatical whitespace (discarded)
memorize a reference to an object.
This class provides support for multi-language string lookup, as needed
to localize messages from applications supporting multiple languages
at the same time.
receives notification of child element of mixed content model.
receives notification of child element of mixed content model.
map from namespace URI to IslandSchema.
An utility class that
reads multiple XML Schema documents and combines them into one schema object.
name of the referenced expression.
this name class matches all the namespaces that are accepted by this anyOtherElement.
constraint over attribute name
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
NameClass x NameClass -> boolean
Override the probe method to define the actual function.
parses <difference> name class.
parses <name> name class.
parses <nsName> 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.
named patterns which are defined by using <define> element.
wildcard should be accepted by any name class.
NameClass that matchs any names in a particular namespace.
parses <namespace> element of RELAX Namespace.
namespace URI of the compatibility datatypes library.
namespace URI that this object belongs to.
namespace URI that this ExternalElementExp belongs to.
namespace URI of the identity constraint.
parses <anyName> name class.
Name class that accepts nothing.
'none' datatype of RELAX.
Receive notification of a Notation Declaration.
Receive notification of a Notation Declaration.
NameClass that acts a not operator.
Parsing state for <nsName>
special expression object that represents the empty set (Φ).
gets the number of matched elements.
Turns on/off the panic mode.
parent XMLSchemaSchema object to which this object belongs.
parent XMLSchemaSchema object to which this object belongs.
scans the specified DOM and sends SAX2 events to the handler.
parses a grammar from the specified source
Parses an additional schema.
parses a grammar from the specified source
normal content; whitespace in markup may be handled
specially if the parser uses the content model.
tables that store all SystemIds that we've read.
Reader may create another SAXParser from this factory
Renders the type (GrammarReader.BackPatch implementation).
Base implementation of XPath matching engine.
paths - field in class com.sun.msv.grammar.xmlschema.
Field XPath that characterizes this field.
Visits Expression and writes it as RELAX NG.
returns false iff 'next' string isn't as provided,
else skips that text and returns true.
Peels the occurence expressions from this expression.
this object must be used to create a new expression
ExpressionPool object that this VGM uses.
expression pool that was used to create these objects
ExpressionPool object which was used to create this module.
ExpressionPool that is associated with this grammar
pool object which was used to construct this grammar.
pops the previous state from the stack
computes the possible names.
namespace prefix to URI conversion map.
returns the string which will be used by ExpressionPrinter
to print this expression.
dumps all the contents of ReferenceContainer.
Adapt a SAX1 processing instruction event.
Receive notification of a Processing Instruction.
Receive notification of a Processing Instruction.
Adds maxOccurs/minOccurs semantics to a given expression.
Adds maxOccurs/minOccurs semantics to a given expression.
pushs the current state into the stack and sets new one
manually adds DataTypeVocabulary into this map.
reader object who is the owner of this object.
state that parses redefinable declaration.
declaration that can be redefined by using <redefine> element.
assigns contents of rhs to this object.
assigns contents of rhs to this object.
assigns contents of rhs to this object.
Updates this object by copying the state from rhs
replaces the current ReferenceExp by newly specified reference exp.
used to parse <redefine> element.
DocumentDeclaration
implementation
Grammar object can be shared among multiple threads, but this object
cannot be shared.
creates an object that validates the specified expression.
Container of ReferenceExp.
Reference to the other expression.
removes all ReferenceExp from AGM.
if this field is non-null,
this field will receive assigned DataType object.
Registers the given public ID as corresponding to a particular
URI, typically a local copy.
Registers a given public ID as corresponding to a particular Java
resource in a given class loader, typically distributed with a
software package.
re-initialize the object with brand new parameters.
VerifierFactory implementation of RELAX Core.
reads RELAX-Namespace-extended RELAX Core.
Namespace URI of RELAX Core
reads RELAX module (classic RELAX module; no namespace extension)
by SAX2 and constructs abstract grammar model.
Visitor interface for RELAX expressions.
"Grammar" of RELAX Namespace.
IslandSchema implementation for RELXA module.
namespace URI of RELAX Namespace.
reads RELAX NG grammar with DTD compatibility annotation
and constructs abstract grammar model.
VerifierFactory implementation of RELAX NG.
Grammar for RELAX NG (with DTD compatibility annotation).
this constructor can be used for the ununified expressions.
Namespace URI of RELAX NG
reads RELAX NG grammar from SAX2 and constructs abstract grammar model.
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.
removes an object from this container.
creates (or retrieves, whatever) the actual, concrete, real
XSDatatype object.
this object renders the actual datatype object.
this object is used to keep the information about
the dependency between late-bind datatype objects.
reports an error to the controller
ErrorHandler
that reports all errors and warnings.
reports a warning to the controller
computes regular expression derivative.
resolves built-in datatypes (URI: http://www.w3.org/2001/XMLSchema)
Gets a built-in datatype as SimpleTypeExp.
obtains a named DataType object referenced by a local name.
obtains a named DataType object referenced by a QName.
obtains the DataTypeLibrary that represents the specified namespace URI.
SAX:
Resolve the given entity into an input source.
obtains InputSource for the specified url.
This entity resolver class provides a number of utilities which can help
managment of external parsed entities in XML.
gets DataType object from type name.
Resolves a simple type name into the corresponding XSDatatypeExp object.
Checks RELAX NG contextual restrictions defined in the section 7.
state that parses <restriction> element.
name of the imported AttributesDecl
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.
RootIncludedSchemaState + final wrap up.
imported ElementDecl object that actually validates this element.
name of the imported Rule
Acceptor that is used to validate root node of the island.
makes sure that the expression does not run away.
Performs all back-patchings.
produces SAX2 event from a DOM tree.
SAXParserFactory implementation that supports validation.
Creates a new instance by using the default SAXParserFactory implementation
as the underlying parser.
Creates a new instance that validates documents against the specified schema.
Creates a new instance that validates documents against the specified schema.
Creates a new instance by specifying the underlying SAXParserFactory
implementation.
Creates a new instance by using a default SAXParserFactory implementation
and the specified schema object.
Creates a new instance that validates documents against the specified schema.
This class is used to wrap SAXException by RuntimeException.
The property/attribute name which is used to set a schema.
base implementation of RELAXFactoryImpl and TREXFactoryImpl
used to parse <schema> element of included schema.
implementation of SchemaProvider by using RELAX Grammar.
creates SchemaProvider from existing RELAXGrammar.
used to parse <schema> element.
XPath matcher that tests the selector of an identity constraint.
selectors of the identity constraint.
state that creates SequenceExp.
Sets the attribtue wildcard.
sets the TypedContentHandler which will received the type-augmented
infoset.
sets the GrammarReaderController object that will control
various aspects of the parsing.
Sets the datatypeLibraryFactory.
this DocumentHandler will receive XML.
Adapt a SAX1 document locator event.
Used by applications to set handling of DTD parsing events.
Lets applications control entity resolution.
Force set the error flag to true.
Tells the resolver whether to ignore MIME types in the documents it
retrieves.
Used by applications to request locale for diagnostics.
Turns on/off the panic mode.
Turns on/off the panic mode.
Sets the ExpressionPool object that will be used during the loading process.
sets the factory object which is used to create XML parsers
to parse schema files.
Sets the strict check flag.
Acceptor that will be used when only one ElementExp matches
the start tag.
base type of this complex type.
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.
a NameClass that accepts only one fixed name.
base interface of the most of parsing states.
map from simple type name to SimpleTypeExp object
State that parses <simpleType> element and its children.
Computes the equivalent but simple name class.
gets the number of ReferenceExps in this container.
ElementExp that is used for <any processContents="skip"/>.
where did this reference is written in the source file.
where did this reference is written in the source file.
where did this reference is written in the source file.
Resolves a QName into a pair of (namespace URI,local name).
Resolves a QName into a pair of (namespace URI,local name).
receives notification of the start of an attribute.
Receive notification that a CDATA section is beginning.
Receive notification that a CDATA section is beginning.
receives notification that parsing of content model is beginning.
receives notification that parsing of content model is beginning.
Adapt a SAX1 start document event.
receives notification of the start of a document.
Receive notification of the beginning of the DTD.
Receive notification of the beginning of the DTD.
Adapt a SAX1 startElement event.
receives notification of the start of an element.
parses <start> declaration.
immutable start tag information
base interface of 'parsing state'.
creates various State object, which in turn parses grammar.
creates various State object, which in turn parses grammar.
creates various State object, which in turn parses grammar.
creates various State object, which in turn parses grammar.
creates various State object, which in turn parses grammar.
creates various State object, which in turn parses grammar.
eats a child element
A child acceptor created by the
createChildAcceptor
method
will be ultimately consumed by the parent through this method.
eats a child element
A child acceptor created by the
createChildAcceptor
method
will be ultimately consumed by the parent through this method.
eats a child element
A child acceptor created by the
createChildAcceptor
method
will be ultimately consumed by the parent through this method.
steps - field in class com.sun.msv.grammar.xmlschema.
XPath each name class represents each step.
character literals are allowed, but Acceptor doesn't care
its contents and where it is appeared.
only whitespaces are allowed.
attentive handling of characters is required.
calculates how character literals should be treated.
choices of all elements that can validly substitute this element.
Switchs InputSource to the specified URL and
parses it by the specified state.
constructor for inline tag.
map from role name to TagClause object
target namespace URI of this schema.
State that always returns the same expression.
VerifierFactory implementation that automatically detects the schema language.
use the default SAXParser.
use this singleton instance instead of creating an object.
the sole instance of this class.
the singleton instance of this object.
primitive unit of XML instance.
chioce of all exported elementRules and hedgeRules.
choice of all global element declarations.
parses <topLevel> element.
Obtains a string representation suitable for quick debugging.
reads TREX grammar from SAX2 and constructs abstract grammar model.
VerifierFactory implementation for TREX.
TREX grammar, which is expressed as <grammar> element.
this constructor can be used for the ununified expressions.
reads TREX grammar from SAX2 and constructs abstract grammar model.
IslandSchema implementation for TREX pattern.
reads extended-TREX grammar (extended by RELAX Namespace)
and constructs IslandSchema.
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.
State can implement this method to be notified by DataType vocabulary
about the result of parsing.
if the size of the array is zero, then that means this token is ignored.