## 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 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
`ValidationStack(Receiver out, int initialValidationMode, SchemaType initialType)` Create a validation stack

Method Summary
`void` `attribute(int nameCode, int 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
`int` `getTopLevelElement()` Get the name of the required top-level element (if any) as a namepool fingerprint
`void` `setConstraintChecker(ConstraintChecker checker)` Set the constraint checker in use (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` `setStartTagBuffer(StartTagBufferEE resolver)`
`void` `setTopLevelElement(int nameCode)` Set the name of the required top-level element (if any) as a namepool code
`void` `setXSIType(SchemaType type)` Set the value of xsi:type, if present.
`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(int nameCode, int 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
`getErrorCode, getInvalidity, isInvalid, reportIfInvalid, reportValidationError, setErrorCode, setInvalidity, usesTypeAnnotations`

Methods inherited from class net.sf.saxon.event.ProxyReceiver
`append, close, comment, getConfiguration, getDocumentLocator, getNamePool, getUnderlyingReceiver, namespace, open, processingInstruction, setSystemId, setUnderlyingReceiver, setUnparsedEntity, startDocument`

Methods inherited from class net.sf.saxon.event.SequenceReceiver
`append, 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 out,
                           int initialValidationMode,
                           SchemaType initialType)

  Create a validation stack

  Parameters:
    `out` - 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(int nameCode)

  Set the name of the required top-level element (if any) as a namepool code

  Parameters:
    `nameCode` - the name of the element that must appear at the root of the subtree being validated

### getTopLevelElement

    public int getTopLevelElement()

  Get the name of the required top-level element (if any) as a namepool fingerprint

  Returns:
    the name of the element that must appear at the root of the subtree being validated, or -1 if none has been set

### setConstraintChecker

    public void setConstraintChecker(ConstraintChecker checker)

  Set the constraint checker in use (if any). The ValidationStack is responsible for telling the constraint checker about the ElementDeclaration that defines the uniqueness constraints for the current element. This is done immediately after the startElement call.

  Parameters:
    `checker` - the constraint checker

### setXSIType

    public void setXSIType(SchemaType type)

  Set the value of xsi:type, if present. This will be called immediately before the startElement call for the element on which the xsi:type attribute appears.

  Parameters:
    `type` - the type referenced by the xsi:type attribute

### setIsNilled

    public void setIsNilled(boolean nilled)

  Indicate whether the current element is nilled

  Parameters:
    `nilled` - true if xsi:nil is set

### setStartTagBuffer

    public void setStartTagBuffer(StartTagBufferEE resolver)

### 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(int nameCode,
                             int typeCode,
                             int locationId,
                             int properties)
                      throws XPathException

  Process element start tag

  Specified by:
    `startElement` in interface `Receiver`
  Overrides:
    `startElement` in class `ProxyReceiver`
  Parameters:
    `nameCode` - 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`

### 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(int nameCode,
                          int 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`

### 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`

### endElement

    public void endElement()
                    throws XPathException

  End of element

  Specified by:
    `endElement` in interface `Receiver`
  Overrides:
    `endElement` in class `ProxyReceiver`
  Throws:
    `XPathException`

### 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`

### 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-2010 Saxonica Limited. All rights reserved.