com.saxonica.schema

## Class AllModelGroup

- java.lang.Object
- - com.saxonica.schema.SchemaStructure
  - - com.saxonica.schema.ModelGroup
    - - com.saxonica.schema.AllModelGroup

- All Implemented Interfaces:
    Term, UserSchemaComponent, Serializable, SourceLocator, SchemaComponent

      public class AllModelGroup
      extends ModelGroup

  An AllModelGroup represents an xs:all element in the schema
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from class com.saxonica.schema.ModelGroup

      `contentModel, simplifiedContentModel`

    - ### Fields inherited from interface net.sf.saxon.type.SchemaComponent

      `COMPONENT_FUNCTION_TYPE, FIXED_UP, INCOMPLETE, INVALID, UNVALIDATED, VALIDATED, VALIDATING`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AllModelGroup()` Create an AllModelGroup

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addParticle(Particle particle)` Adds a given Particle to the content model defined by this Compositor
    `protected static String` | `allSubsumes(UserComplexType base, ComplexType sub, SchemaCompiler compiler)` Test whether a complex type constructed using "all" subsumes another complex type.
    `protected boolean` | `checkElements(IntHashMap<ElementDecl> map, SchemaCompiler compiler)` Check that the elements defined as particles in this compositor are consistent (overrides method on parent class ModelGroup)
    `boolean` | `containsAll(boolean simplified)` Determine if the content model uses xs:all.
    `void` | `elaborate(SchemaCompiler compiler)` Elaborate the schema component: after reloading a serialized schema component model, this expands the component with derived information needed during validation episodes.
    `String` | `getCompositorName()` Get the name of this compositor
    `IntToIntMap` | `getCounterMap()` Get a mapping from element name fingerprints (including fingerprints of substitution group members) to entries in the minima and maxima arrays.
    `IntHashMap` | `getDeclarationMap()` Get a mapping from element name fingerprints (including fingerprints of substitution group members) to local or global element declarations to be used to validate the content of each element in the all group
    `int[]` | `getMaxima()` Get the values of maxOccurs() for all the particles, as an array
    `int[]` | `getMinima()` Get the values of minOccurs() for all the particles, as an array
    `int[]` | `getNameCodes()` Get the namecodes of the element particles corresponding to each item in the maxima/minima arrays.
    `int` | `getNumberOfElementParticles()` Get the number of element particles
    `List<Particle>` | `getSimplifiedContentModel()` Remove pointless particles from this content model (recursively), and replace group references by the content of the identified group
    `List<ElementWildcard>` | `getWildcards()` Get the list of element wildcards (XSDL 1.1 only)
    `boolean` | `isEmptiable()` Determine if empty content is allowed
    `boolean` | `isPointless(ModelGroup container)` Test whether the compositor is pointless, as described in XML Schema Part 1 Schema Component Constraint: Particle Valid (Restriction)
    `boolean` | `validate(SchemaCompiler compiler)` Checks the validity of this Compositor definition.

    - ### Methods inherited from class com.saxonica.schema.ModelGroup

      `compile, containsElementWildcard, fixup, gatherAllPermittedElements, getComponentAsFunction, getContentModelSize, getElementParticleCardinality, getElementParticleType, getParticles, getTerm, isEmpty, lookForCycles, markVulnerableSubParticles, serialize, setContentModel`

    - ### Methods inherited from class com.saxonica.schema.SchemaStructure

      `getColumnNumber, getConfiguration, getFixupStatus, getLineNumber, getPublicId, getRedefinitionLevel, getSchemaDocumentURI, getSystemId, getValidationStatus, makeXPathExpressionPropertyRecord, setConfiguration, setFixupStatus, setLineNumber, setLocator, setRedefinitionLevel, setSchemaDocumentURI, setSystemId, setValidationStatus`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface net.sf.saxon.type.SchemaComponent

      `getRedefinitionLevel, getValidationStatus`

- - ### Constructor Detail

    - #### AllModelGroup

          public AllModelGroup()

      Create an AllModelGroup

  - ### Method Detail

    - #### addParticle

          public void addParticle(Particle particle)

      Adds a given Particle to the content model defined by this Compositor
      Overrides:
        `addParticle` in class `ModelGroup`
      Parameters:
        `particle` - the Particle to be added

    - #### getNumberOfElementParticles

          public int getNumberOfElementParticles()

      Get the number of element particles
      Returns:
        the number of element particles in the content model

    - #### containsAll

          public boolean containsAll(boolean simplified)

      Determine if the content model uses xs:all.
      Overrides:
        `containsAll` in class `ModelGroup`
      Parameters:
        `simplified` - set to false if we want to look at the original unsimplified content model, to true if we want the model after removing pointless particles
      Returns:
        true (always)

    - #### isEmptiable

          public boolean isEmptiable()
                              throws UnresolvedReferenceException

      Determine if empty content is allowed
      Specified by:
        `isEmptiable` in class `ModelGroup`
      Returns:
        true if this content model permits empty content
      Throws:
        `UnresolvedReferenceException` - if the schema contains unresolved references to required components

    - #### isPointless

          public boolean isPointless(ModelGroup container)

      Test whether the compositor is pointless, as described in XML Schema Part 1 Schema Component Constraint: Particle Valid (Restriction)
      Overrides:
        `isPointless` in class `ModelGroup`
      Parameters:
        `container` - not used
      Returns:
        true if the particle is pointless (which effectively means it can't match anything)

    - #### checkElements

          protected boolean checkElements(IntHashMap<ElementDecl> map,
                              SchemaCompiler compiler)
                                   throws SchemaException,
                                          UnresolvedReferenceException

      Check that the elements defined as particles in this compositor are consistent (overrides method on parent class ModelGroup)
      Overrides:
        `checkElements` in class `ModelGroup`
      Parameters:
        `map` - a HashMap that maps integers to ElementDecl's
        `compiler` - used for error reporting
      Returns:
        true of the elements are consistent
      Throws:
        `SchemaException` - if the schema is invalid
        `UnresolvedReferenceException` - if the schema contains unresolved references to required components

    - #### getCompositorName

          public String getCompositorName()

      Get the name of this compositor
      Specified by:
        `getCompositorName` in class `ModelGroup`
      Returns:
        one of "sequence", "choice", or "all"

    - #### getSimplifiedContentModel

          public List<Particle> getSimplifiedContentModel()

      Remove pointless particles from this content model (recursively), and replace group references by the content of the identified group
      Overrides:
        `getSimplifiedContentModel` in class `ModelGroup`
      Returns:
        the simplified content model

    - #### validate

          public boolean validate(SchemaCompiler compiler)
                           throws SchemaException

      Checks the validity of this Compositor definition.
      Specified by:
        `validate` in interface `UserSchemaComponent`
      Overrides:
        `validate` in class `ModelGroup`
      Returns:
        true when this Schema definition is valid, otherwise false.
      Throws:
        `SchemaException` - when the error listener decides an error is fatal

    - #### elaborate

          public void elaborate(SchemaCompiler compiler)
                         throws SchemaException

      Elaborate the schema component: after reloading a serialized schema component model, this expands the component with derived information needed during validation episodes. The model is assumed to be valid.
      Specified by:
        `elaborate` in interface `UserSchemaComponent`
      Overrides:
        `elaborate` in class `SchemaStructure`
      Parameters:
        `compiler` - the schema compiler
      Throws:
        `SchemaException`

    - #### getMaxima

          public int[] getMaxima()

      Get the values of maxOccurs() for all the particles, as an array
      Returns:
        an array containing the maxOccurs() values. The value "unbounded" is represented as -1. The entry in the array for a given element name can be found using the counterMap.

    - #### getMinima

          public int[] getMinima()

      Get the values of minOccurs() for all the particles, as an array
      Returns:
        an array containing the minOccurs() values. The entry in the array for a given element name can be found using the counterMap.

    - #### getNameCodes

          public int[] getNameCodes()

      Get the namecodes of the element particles corresponding to each item in the maxima/minima arrays.
      Returns:
        an array containing the nameCode values.

    - #### getCounterMap

          public IntToIntMap getCounterMap()

      Get a mapping from element name fingerprints (including fingerprints of substitution group members) to entries in the minima and maxima arrays. Note that this includes entries for all members of substitution groups, so several fingeprints map to the same counter position
      Returns:
        a map from element fingerprints to counter positions

    - #### getDeclarationMap

          public IntHashMap getDeclarationMap()

      Get a mapping from element name fingerprints (including fingerprints of substitution group members) to local or global element declarations to be used to validate the content of each element in the all group
      Returns:
        a map from element name fingerprints to element declarations

    - #### getWildcards

          public List<ElementWildcard> getWildcards()

      Get the list of element wildcards (XSDL 1.1 only)
      Returns:
        a list holding the element wildcards defined in this model group, or an empty list if there are none

    - #### allSubsumes

          protected static String allSubsumes(UserComplexType base,
                           ComplexType sub,
                           SchemaCompiler compiler)
                                       throws SchemaException

      Test whether a complex type constructed using "all" subsumes another complex type. This test is always done after simplification of the content model
      Parameters:
        `base` - the base type, which must be defined using xs:all
        `sub` - the type that is (supposedly) subsumed by the base type
        `compiler` - used for reporting errors and warnings
      Returns:
        null if the "all" particle subsumes the other; otherwise, a string explaining why not. If the string starts with "?", this means Saxon is unable to prove one way or the other whether the derived type is a valid restriction or not.
      Throws:
        `SchemaException` - if the schema is not valid

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.