## com.saxonica.validate
Class ContentValidator

    java.lang.Object
      net.sf.saxon.event.SequenceReceiver
          net.sf.saxon.event.ProxyReceiver
              com.saxonica.validate.ContentValidator

All Implemented Interfaces:
  Result, Receiver

Direct Known Subclasses:
  AttributeValidator, LaxValidator, StripValidator

    public abstract class ContentValidator

extends ProxyReceiver

This class is an abstract superclass for all the validators. The class includes factory methods for constructing a validator.

Field Summary
`static int` `NIL_ALLOWED` Constant indicating that xsi:nil is allowed and active.
`static int` `NIL_DISALLOWED` Constant indicating that xsi:nil is disallowed.
`static int` `NIL_IGNORED` Constant indicating that xsi:nil is allowed but ignored; this is true when we are validating against a type, rather than against an element declaration

Fields inherited from interface javax.xml.transform.Result
`PI_DISABLE_OUTPUT_ESCAPING, PI_ENABLE_OUTPUT_ESCAPING`

Constructor Summary
`ContentValidator()`

Method Summary
`void` `endDocument()` Notify the end of a document node
`int` `getContainingElement()` Get the fingerprint of the name of the element being validated (for diagnostics).
`int` `getContainingElementLocationId()` Get the location ID of the element being validated
`ElementDecl` `getElementDeclaration()` Get the element declaration that this validator is validating against
`NamespaceResolver` `getNamespaceResolver()` Get the namespace resolver
`int` `getNillability()` Determine whether this type permits xsi:nil = true BlockCom
`boolean` `isInvalid()` Determine if an error was found
`boolean` `isNil()` Determine whether xsi:nil = true was set on this element
`boolean` `isOutput()` Determine whether this validator is being used for an output document
`static ContentValidator` `makeValidator(ElementDecl elementDecl, SchemaType schemaType, PipelineConfiguration pipe)` Factory method to create a validator for elements of a given type
`static ContentValidator` `makeValidator(int nameCode, int locationId, SchemaType xsiType, int validation, PipelineConfiguration pipe)` Factory method to make a validator for a particular element
`void` `setContainingElement(int fingerprint, int locationId)` Set the fingerprint identifying the name of the containing element (for diagnostics)
`void` `setElementDeclaration(ElementDecl decl)` Set the element declaration that this validator is validating against
`void` `setErrorCode(String errorCode)` Set the error code to be thrown by this validator if an error is encountered
`void` `setIsOutput(boolean output)` Indicate that this validator is being used for an output document.
`void` `setNamespaceResolver(NamespaceResolver resolver)` Set the NamespaceResolver to be used for resolving QName-valued attributes
`void` `setNillability(int nillability)` Set whether this type permits xsi:nil = true
`void` `setXSIType(SchemaType xsiType)` Set the value of the xsi:type attribute.
`void` `startElement(int nameCode, int typeCode, int locationId, int properties)` Handle the start tag for a child element of the element being validated

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

Methods inherited from class net.sf.saxon.event.SequenceReceiver
`getPipelineConfiguration, getSystemId`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### NIL_IGNORED

    public static final int NIL_IGNORED

  Constant indicating that xsi:nil is allowed but ignored; this is true when we are validating against a type, rather than against an element declaration

  See Also:
    Constant Field Values

### NIL_ALLOWED

    public static final int NIL_ALLOWED

  Constant indicating that xsi:nil is allowed and active. That is, we are validating against an element declaration that specifies nillable=true

  See Also:
    Constant Field Values

### NIL_DISALLOWED

    public static final int NIL_DISALLOWED

  Constant indicating that xsi:nil is disallowed. That is, we are validating against an element declaration that specifies nillable=false

  See Also:
    Constant Field Values

Constructor Detail

### ContentValidator

    public ContentValidator()

Method Detail

### setContainingElement

    public void setContainingElement(int fingerprint,
                                     int locationId)

  Set the fingerprint identifying the name of the containing element (for diagnostics)

  Parameters:
    `fingerprint` -

### setElementDeclaration

    public void setElementDeclaration(ElementDecl decl)

  Set the element declaration that this validator is validating against

### getElementDeclaration

    public ElementDecl getElementDeclaration()

  Get the element declaration that this validator is validating against

### getContainingElement

    public int getContainingElement()

  Get the fingerprint of the name of the element being validated (for diagnostics).

  Returns:
    the fingerprint, or -1 if not available.

### getContainingElementLocationId

    public int getContainingElementLocationId()

  Get the location ID of the element being validated

  Returns:
    the location ID, or 0 if not available

### setErrorCode

    public void setErrorCode(String errorCode)

  Set the error code to be thrown by this validator if an error is encountered

### setXSIType

    public void setXSIType(SchemaType xsiType)

  Set the value of the xsi:type attribute. This is called immediately before the call of startElement on which the xsi:type attribute appears.

### setNamespaceResolver

    public void setNamespaceResolver(NamespaceResolver resolver)

  Set the NamespaceResolver to be used for resolving QName-valued attributes

### getNamespaceResolver

    public NamespaceResolver getNamespaceResolver()

  Get the namespace resolver

### setNillability

    public void setNillability(int nillability)

  Set whether this type permits xsi:nil = true

### getNillability

    public int getNillability()

  Determine whether this type permits xsi:nil = true BlockCom

  Returns:
    one of `NIL_IGNORED`, `NIL_ALLOWED`, `NIL_DISALLOWED`

### isNil

    public boolean isNil()

  Determine whether xsi:nil = true was set on this element

  Returns:
    true if xsi:nil="true" was set

### setIsOutput

    public void setIsOutput(boolean output)

  Indicate that this validator is being used for an output document. This allows errors to be treated as warnings

### isOutput

    public boolean isOutput()

  Determine whether this validator is being used for an output document

### startElement

    public void startElement(int nameCode,
                             int typeCode,
                             int locationId,
                             int properties)
                      throws XPathException

  Handle the start tag for a child element of the element being validated

  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`

### makeValidator

    public static ContentValidator makeValidator(int nameCode,
                                                 int locationId,
                                                 SchemaType xsiType,
                                                 int validation,
                                                 PipelineConfiguration pipe)
                                          throws XPathException

  Factory method to make a validator for a particular element

  Parameters:
    `nameCode` - the name of the element to be validated
    `locationId` - the location of the stylesheet instruction that generated this element (or zero)
    `xsiType` - the type identified by xsi:type, if specified; otherwise null
    `validation` - the validation mode (strict, lax, preserve, strip)
    `pipe` - the pipeline configuration
  Returns:
    a Validator suitable for validating the content of this element
  Throws:
    `XPathException`

### makeValidator

    public static ContentValidator makeValidator(ElementDecl elementDecl,
                                                 SchemaType schemaType,
                                                 PipelineConfiguration pipe)
                                          throws ValidationException

  Factory method to create a validator for elements of a given type

  Parameters:
    `elementDecl` - the element declaration if available, otherwise null (there will be no element declaration, for example, when doing lax validation against an xsi:type)
    `schemaType` - the simple or complex type against which the content of the element is to be validated
    `pipe` - the pipeline configuration
  Returns:
    a Validator that can sit in the event pipeline to perform local validation of elements declared to have this type
  Throws:
    `ValidationException`

### isInvalid

    public boolean isInvalid()

  Determine if an error was found

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

Copyright (C) Michael H. Kay. All rights reserved.