Class AllModelGroup

All Implemented Interfaces:
Term, UserSchemaComponent, SourceLocator, Location, SchemaComponent, Locator

public class AllModelGroup extends ModelGroup
An AllModelGroup represents an xs:all element in the schema
  • Constructor Details

    • AllModelGroup

      public AllModelGroup()
      Create an AllModelGroup
  • Method Details

    • 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 MissingComponentException
      Determine if empty content is allowed
      Specified by:
      isEmptiable in class ModelGroup
      Returns:
      true if this content model permits empty content
      Throws:
      MissingComponentException - 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, MissingComponentException
      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
      MissingComponentException - 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() throws MissingComponentException
      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
      Throws:
      MissingComponentException
    • 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
      Parameters:
      compiler - the schema compiler
      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 StructuredQName[] 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<ElementDecl> 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