com.saxonica.validate

## Class ValidationStack

- java.lang.Object
- - net.sf.saxon.event.SequenceReceiver
  - - net.sf.saxon.event.ProxyReceiver
    - - com.saxonica.validate.ValidatingFilter
      - - com.saxonica.validate.ValidationStack

- All Implemented Interfaces:
    Result, Receiver

      public class ValidationStack
      extends ValidatingFilter

  This class manages the receivers that do element content validation. It maintains a stack of Validators, each of which does local element validation of the contents of a single element, adding a new validator to the stack to handle each layer of nesting.

- - ### Field Summary

    - ### Fields inherited from class com.saxonica.validate.ValidatingFilter

      `locallyInvalid`

    - ### Fields inherited from class net.sf.saxon.event.ProxyReceiver

      `nextReceiver`

    - ### Fields inherited from class net.sf.saxon.event.SequenceReceiver

      `pipelineConfiguration, previousAtomic, systemId`

    - ### Fields inherited from interface javax.xml.transform.Result

      `PI_DISABLE_OUTPUT_ESCAPING, PI_ENABLE_OUTPUT_ESCAPING`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ValidationStack(Receiver next, int initialValidationMode, SchemaType initialType)` Create a validation stack

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `attribute(NodeName nameCode, SimpleType typeCode, CharSequence value, int locationId, int properties)` Handle an attribute
    `void` | `characters(CharSequence chars, int locationId, int properties)` Character data
    `void` | `endDocument()` Notify the end of a document node
    `void` | `endElement()` End of element
    `Map<SchemaComponent,Integer>` | `getCoverageStatistics()` Get the statistics showing the usage of individual schema components during a validation episode
    `NodeName` | `getTopLevelElement()` Get the name of the required top-level element (if any)
    `void` | `setInitialValidator(ContentValidator validator)` Set the initial validator to be used for the outermost element
    `void` | `setIsNilled(boolean nilled)` Indicate whether the current element is nilled
    `void` | `setKeepStatistics(boolean keep)` Ask that statistics be maintained for the duration of the validation episode.
    `void` | `setPipelineConfiguration(PipelineConfiguration pipe)` Set the pipeline configuration
    `void` | `setTopLevelElement(NodeName name)` Set the name of the required top-level element (if any)
    `void` | `setUnparsedEntity(String name, String uri, String publicId)` Set the URI for an unparsed entity in the document.
    `void` | `setXsiValidationErrors(List errors)` Supply a list of errors found in attributes in the XSI namespace.
    `void` | `startContent()` Notify the start of the content, that is, the completion of all attributes and namespaces.
    `void` | `startElement(NodeName elemName, SchemaType typeCode, int locationId, int properties)` Process element start tag
    `void` | `testAssertions(NodeInfo root, UserComplexType type)` Test whether all the assertions on a given complex type are true

    - ### Methods inherited from class com.saxonica.validate.ValidatingFilter

      `append, getConstraintChecker, getStartTagBuffer, getValidationContext, reportIfInvalid, reportValidationError, setConstraintChecker, setStartTagBuffer, setValidationContext, usesTypeAnnotations`

    - ### Methods inherited from class net.sf.saxon.event.ProxyReceiver

      `close, comment, getNamePool, getUnderlyingReceiver, namespace, open, processingInstruction, setSystemId, setUnderlyingReceiver, startDocument`

    - ### Methods inherited from class net.sf.saxon.event.SequenceReceiver

      `append, getConfiguration, getPipelineConfiguration, getSystemId`

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

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

- - ### Constructor Detail

    - #### ValidationStack

          public ValidationStack(Receiver next,
                         int initialValidationMode,
                         SchemaType initialType)

      Create a validation stack
      Parameters:
        `next` - the destination of events after passing through validation
        `initialValidationMode` - the initial validation mode, strict/lax
        `initialType` - the initial type to validate against, if any

  - ### Method Detail

    - #### setPipelineConfiguration

          public void setPipelineConfiguration(PipelineConfiguration pipe)

      Description copied from interface: `Receiver`
      Set the pipeline configuration
      Specified by:
        `setPipelineConfiguration` in interface `Receiver`
      Overrides:
        `setPipelineConfiguration` in class `ProxyReceiver`
      Parameters:
        `pipe` - the pipeline configuration

    - #### setTopLevelElement

          public void setTopLevelElement(NodeName name)

      Set the name of the required top-level element (if any)
      Parameters:
        `name` - the name of the element that must appear at the root of the subtree being validated

    - #### getTopLevelElement

          public NodeName getTopLevelElement()

      Get the name of the required top-level element (if any)
      Returns:
        the name of the element that must appear at the root of the subtree being validated, or null if none has been set

    - #### setUnparsedEntity

          public void setUnparsedEntity(String name,
                               String uri,
                               String publicId)
                                 throws XPathException

      Set the URI for an unparsed entity in the document.
      Specified by:
        `setUnparsedEntity` in interface `Receiver`
      Overrides:
        `setUnparsedEntity` in class `ProxyReceiver`
      Parameters:
        `name` - The name of the unparsed entity
        `uri` - The system identifier of the unparsed entity
        `publicId` - The public identifier of the unparsed entity
      Throws:
        `XPathException` - if an error occurs

    - #### setIsNilled

          public void setIsNilled(boolean nilled)

      Indicate whether the current element is nilled
      Parameters:
        `nilled` - true if xsi:nil is set

    - #### setXsiValidationErrors

          public void setXsiValidationErrors(List errors)

      Supply a list of errors found in attributes in the XSI namespace. This is called immediately before calling startElement on the element containing these erroneous attributes

    - #### startElement

          public void startElement(NodeName elemName,
                          SchemaType typeCode,
                          int locationId,
                          int properties)
                            throws XPathException

      Process element start tag
      Specified by:
        `startElement` in interface `Receiver`
      Overrides:
        `startElement` in class `ProxyReceiver`
      Parameters:
        `elemName` - integer code identifying the name of the element within the name pool.
        `typeCode` - integer code identifying the element's type within the name pool.
        `locationId` - an integer which can be interpreted using a `LocationProvider` to return information such as line number and system ID. If no location information is available, the value zero is supplied.
        `properties` - properties of the element node
      Throws:
        `XPathException` - if an error occurs

    - #### setInitialValidator

          public void setInitialValidator(ContentValidator validator)

      Set the initial validator to be used for the outermost element
      Parameters:
        `validator` - the validator to be used for the outermost element being validated

    - #### attribute

          public void attribute(NodeName nameCode,
                       SimpleType typeCode,
                       CharSequence value,
                       int locationId,
                       int properties)
                         throws XPathException

      Handle an attribute
      Specified by:
        `attribute` in interface `Receiver`
      Overrides:
        `attribute` in class `ProxyReceiver`
      Parameters:
        `nameCode` - integer identifying the name of the attribute
        `typeCode` - integer identifying the pre-validation type annotation (typically untypedAtomic)
        `value` - the value of the attribute
        `properties` - additional properties of the attribute
        `locationId` - an integer which can be interpreted using a `LocationProvider` to return information such as line number and system ID. If no location information is available, the value zero is supplied.
      Throws:
        `XPathException` - On any failure to write the attribute

    - #### startContent

          public final void startContent()
                                  throws XPathException

      Notify the start of the content, that is, the completion of all attributes and namespaces. Note that the initial receiver of output from XSLT instructions will not receive this event, it has to detect it itself. Note that this event is reported for every element even if it has no attributes, no namespaces, and no content.
      Specified by:
        `startContent` in interface `Receiver`
      Overrides:
        `startContent` in class `ProxyReceiver`
      Throws:
        `XPathException` - if an error occurs

    - #### characters

          public void characters(CharSequence chars,
                        int locationId,
                        int properties)
                          throws XPathException

      Description copied from class: `ProxyReceiver`
      Character data
      Specified by:
        `characters` in interface `Receiver`
      Overrides:
        `characters` in class `ProxyReceiver`
      Parameters:
        `chars` - The characters
        `locationId` - an integer which can be interpreted using a `LocationProvider` to return information such as line number and system ID. If no location information is available, the value zero is supplied.
        `properties` - Bit significant value. The following bits are defined:
      DISABLE_ESCAPING
        Disable escaping for this text node
      USE_CDATA
        Output as a CDATA section
      Throws:
        `XPathException` - if an error occurs

    - #### endElement

          public void endElement()
                          throws XPathException

      End of element
      Specified by:
        `endElement` in interface `Receiver`
      Overrides:
        `endElement` in class `ProxyReceiver`
      Throws:
        `XPathException` - if an error occurs

    - #### endDocument

          public void endDocument()
                           throws XPathException

      Notify the end of a document node
      Specified by:
        `endDocument` in interface `Receiver`
      Overrides:
        `endDocument` in class `ProxyReceiver`
      Throws:
        `XPathException` - if an error occurs

    - #### testAssertions

          public void testAssertions(NodeInfo root,
                            UserComplexType type)
                              throws XPathException

      Test whether all the assertions on a given complex type are true
      Parameters:
        `root` - the element whose assertions are to be tested
        `type` - the type on which the assertions are defined
      Throws:
        `ValidationException` - if any of the assertions are not true
        `XPathException`

    - #### setKeepStatistics

          public void setKeepStatistics(boolean keep)

      Ask that statistics be maintained for the duration of the validation episode. The statistics indicate how often particular schema components (currently, element declarations and types) have been used.
      Parameters:
        `keep` - true if statistics are to be kept, false if not

    - #### getCoverageStatistics

          public Map<SchemaComponent,Integer> getCoverageStatistics()

      Get the statistics showing the usage of individual schema components during a validation episode
      Returns:
        a table showing for each component that has been used, the number of times it has been used. If statistics are not being maintained, returns null.

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