Package com.saxonica.ee.schema

Class Particle

    • Field Detail

      • UNBOUNDED

        public static final int UNBOUNDED
        A constant to represent an UNBOUNDED number of occurrences
        See Also:
        Constant Field Values

    • Constructor Detail

      • Particle

        public Particle()

    • Method Detail

      • getMaxOccurs

        public final int getMaxOccurs()
        Returns the maximum number of occurrences that this Particle may appear in the containing content model
        Returns:
        the maximum number of occurrences that this Particle may appear. A negative (n < 0) value indicates that the value is unspecified (i.e. unbounded).

      • getMinOccurs

        public final int getMinOccurs()
        Returns the minimum number of occurrences that this Particle must appear in the containing content model
        Returns:
        the minimum number of occurrences that this Particle must appear A negative (n < 0) value indicates that the value is unspecified.

      • setMaxOccurs

        public final void setMaxOccurs​(int maxOccurs)
        Sets the maximum number of occurrences for this Particle within the containing content model
        Parameters:
        maxOccurs - the maximum number of occurrences for this Particle, or -1 to indicate that the maximum is unbounded

      • setMinOccurs

        public final void setMinOccurs​(int minOccurs)
        Sets the minimum number of occurrences for this Particle within the containing content model
        Parameters:
        minOccurs - the minimum number of occurrences for this Particle

      • setVulnerable

        public final void setVulnerable​(boolean vulnerable)
        Mark the particle as being (or not being) vulnerable.
        Parameters:
        vulnerable - true if the particle is vulnerable. A particle is vulnerable if (a) it is contained in a particle that allows repetition, and (b) everything both before and after it in its enclosing particle is optional, that is, the input it accepts may be all that its enclosing particle accepts.

      • isVulnerable

        public final boolean isVulnerable()
        Ask whether the particle is vulnerable.
        Returns:
        true if the particule is marked as vulnerable. A particle is vulnerable if (a) it is contained in a particle that allows repetition, and (b) everything both before and after it in its enclosing particle is optional, that is, the input it accepts may be all that its enclosing particle accepts. The significance of this concept arises when compiling finite state machines with counters; counters are simply not used in the case of a content model like (a(2,4))(3,5); marking the ElementParticle a as vulnerable suppresses the use of counters. Example: MS tests, particlesT014

      • computeParticleCardinality

        public static int computeParticleCardinality​(int minOccurs,
                                             int maxOccurs)
        Compute an XPath cardinality (e.g. ONE_OR_MORE) from an XML Schema cardinality
        Parameters:
        minOccurs - Minimum occurrences
        maxOccurs - Maximum occurrences (-1 = unbounded)
        Returns:
        The XPath cardinality

      • containsElementWildcard

        public abstract boolean containsElementWildcard()
                                         throws MissingComponentException
        Ask whether the particle contains an element wildcard
        Returns:
        true if the particle is an element wildcard, or contains one
        Throws:
        MissingComponentException

      • gatherAllPermittedElements

        public abstract void gatherAllPermittedElements​(IntHashSet result,
                                                boolean ignoreWildcards)
                                         throws SchemaException
        Find the set of all element particles allowed within the content model of this particle. Ignore wildcards.
        Parameters:
        result - an initially-empty set in which the results are accumulated
        ignoreWildcards - if true, wildcards are ignored. If false, the result will contain the name XS_INVALID, meaning that it is not possible to enumerate the elements that can appear in the content.
        Throws:
        SchemaException - if an error is found in the schema

      • isEmptiable

        public abstract boolean isEmptiable()
                             throws MissingComponentException
        Determine if empty content is allowed
        Returns:
        true if the particle matches empty content
        Throws:
        MissingComponentException - if the schema contains an unresolved reference to a required component

      • getElementParticleType

        public abstract SchemaType getElementParticleType​(int fingerprint)
                                           throws MissingComponentException
        Find an element particle within this part of a content model having a given element name (identified by fingerprint), and return the schema type associated with that element particle. If there is no such particle, return null. If the fingerprint matches an element wildcard, return the type of the global element declaration with the given name if one exists, or AnyType if none exists and lax validation is permitted by the wildcard.
        Parameters:
        fingerprint - Identifies the name of the child element within this content model
        Returns:
        the type of the element identified by the given name fingerprint. The consistency rule "Element Declarations Consistent" ensures that if there are multiple matching declarations, they have consistent types
        Throws:
        MissingComponentException

      • validate

        public abstract boolean validate​(SchemaCompiler compiler)
                          throws SchemaException
        Check the validity (consistency) of this element definition.
        Specified by:
        validate in interface UserSchemaComponent
        Parameters:
        compiler - the schema compiler
        Returns:
        true if validation succeeded, false if errors were found.
        Throws:
        SchemaException - if an error is found and the error listener decides that the error is fatal

      • isPointless

        public abstract boolean isPointless​(ModelGroup container)
                             throws MissingComponentException
        Test whether the particle is pointless, as described in XML Schema Part 1 Schema Component Constraint: Particle Valid (Restriction)
        Parameters:
        container - the model group containing this particle; null if there is no containing model group
        Returns:
        true if the particle is pointless (for example, a sequence of one item)
        Throws:
        MissingComponentException

      • getComponentAsFunction

        public Function getComponentAsFunction()
        Description copied from interface: SchemaComponent
        Get the schema component in the form of a function item. This allows schema information to be made visible to XSLT or XQuery code. The function makes available the contents of the schema component as defined in the XSD specification. The function takes a string as argument representing a property name, and returns the corresponding property of the schema component. There is also a property "class" which returns the kind of schema component, for example "Attribute Declaration".
        Specified by:
        getComponentAsFunction in interface SchemaComponent
        Returns:
        the schema component represented as a function from property names to property values.