com.saxonica.schema

## Class Assertion

- java.lang.Object
- - com.saxonica.schema.SchemaStructure
  - - com.saxonica.schema.Assertion

- All Implemented Interfaces:
    SerializableSchemaComponent, Serializable, SourceLocator, SchemaComponent

      public class Assertion
      extends SchemaStructure
      implements SchemaComponent, SerializableSchemaComponent

  An Assertion schema component (See XML Schema 1.1 Part 1 Working Draft)
  See Also:
    Serialized Form

- - ### Field Summary

    - ### 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
    `Assertion(EnterpriseConfiguration config, XPathExpression condition, XPathVariable valueVariable, Map<StructuredQName,XPathVariable> params, String text)` Create an Assertion component

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `equals(Object other)` equals() is used when deciding whether two assertions are equal, as part of the type subsumption algorithm.
    `FunctionItem` | `getComponentAsFunction()` Get the schema component in the form of a function item.
    `XPathExpression` | `getCondition()` Get the XPath expression representing the assertion.
    `String` | `getConditionText()` Get the original text of the condition.
    `String` | `getMessage()` Get the user-defined error message associated with the assertion
    `XPathStaticContext` | `getStaticContext()` Get the static context for the expression
    `XPathVariable` | `getValueVariable()` Get the variable bound to the name $value
    `int` | `hashCode()` Hashcode is used when deciding whether two assertions are equal, as part of the type subsumption algorithm.
    `void` | `serialize(SchemaModelSerializer serializer)` Serialize the schema component
    `void` | `setMessage(String message)` Set the user-defined error message associated with the assertion
    `void` | `setStaticContext(XPathStaticContext staticContext)` Set the static context for the expression.
    `List<Item>` | `test(Item contextItem, Sequence value, ConversionRules rules)` Evaluate the assertion

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

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

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

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

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

      `getRedefinitionLevel, getValidationStatus`

- - ### Constructor Detail

    - #### Assertion

          public Assertion(EnterpriseConfiguration config,
                   XPathExpression condition,
                   XPathVariable valueVariable,
                   Map<StructuredQName,XPathVariable> params,
                   String text)

      Create an Assertion component
      Parameters:
        `config` - the Saxon configuration
        `condition` - the compiled XPath expression
        `valueVariable` - the variable to hold $value (may be null)
        `params` - parameters declared using saxon:param and used in this expression
        `text` - the original text of the XPath expression

  - ### Method Detail

    - #### getCondition

          public XPathExpression getCondition()

      Get the XPath expression representing the assertion. If xs:report is used, this will be the negation of the condition in the source schema.
      Returns:
        the XPath expression

    - #### getValueVariable

          public XPathVariable getValueVariable()

      Get the variable bound to the name $value
      Returns:
        the variable whose name is $value (may be null)

    - #### getConditionText

          public String getConditionText()

      Get the original text of the condition.
      Returns:
        the original text of the XPath expression

    - #### setMessage

          public void setMessage(String message)

      Set the user-defined error message associated with the assertion
      Parameters:
        `message` - the message defined using the saxon:message attribute, if present

    - #### getMessage

          public String getMessage()

      Get the user-defined error message associated with the assertion
      Returns:
        the user-defined error message, if any; otherwise null

    - #### setStaticContext

          public void setStaticContext(XPathStaticContext staticContext)

      Set the static context for the expression. Note: this is needed only to support exporting of the schema component model
      Parameters:
        `staticContext` - the static context

    - #### getStaticContext

          public XPathStaticContext getStaticContext()

      Get the static context for the expression
      Returns:
        the static context

    - #### test

          public List<Item> test(Item contextItem,
                        Sequence value,
                        ConversionRules rules)

      Evaluate the assertion
      Parameters:
        `contextItem` - the item to be used as the context item in evaluating the condition
        `value` - the simple value to be tested, if any. If present, and if the expression uses $value, this value will be bound to the variable $value for evaluating the assertion.
        `rules` - used to provide context information including the current error listener, URIResolver, and document pool, current date/time, etc. To take advantage of validation parameters (saxon:param) this must be a ValidationContext; but on other paths such as casting it is not possible to supply parameters, and the defaults are used
      Returns:
        null if the assertion succeeds; otherwise a list of offending items which will be reported in any error message. Returning an empty list indicates that the assertion has failed but there are no specific offending items to be reported.

    - #### hashCode

          public int hashCode()

      Hashcode is used when deciding whether two assertions are equal, as part of the type subsumption algorithm. Assertions are equal if their XPath expressions are equal.
      Overrides:
        `hashCode` in class `Object`

    - #### equals

          public boolean equals(Object other)

      equals() is used when deciding whether two assertions are equal, as part of the type subsumption algorithm. Assertions are equal if their XPath expressions are equal.
      Overrides:
        `equals` in class `Object`

    - #### serialize

          public void serialize(SchemaModelSerializer serializer)
                         throws XPathException

      Serialize the schema component
      Specified by:
        `serialize` in interface `SerializableSchemaComponent`
      Parameters:
        `serializer` - the object responsible for performing the serialization
      Throws:
        `XPathException` - if serialization fails

    - #### getComponentAsFunction

          public FunctionItem getComponentAsFunction()

      Description copied from interface: `SchemaComponent`
      Get the schema component in the form of a function item. This allows schema information to be made visible to XSLT or XQuery code. The function makes available the contents of the schema component as defined in the XSD specification. The function takes a string as argument representing a property name, and returns the corresponding property of the schema component. There is also a property "class" which returns the kind of schema component, for example "Attribute Declaration".
      Specified by:
        `getComponentAsFunction` in interface `SchemaComponent`
      Returns:
        the schema component represented as a function from property names to property values.

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