## net.sf.saxon.expr
Class ItemChecker

    java.lang.Object
      |
      +--net.sf.saxon.expr.ComputedExpression
            |
            +--net.sf.saxon.expr.UnaryExpression
                  |
                  +--net.sf.saxon.expr.ItemChecker

All Implemented Interfaces:
  Container, Expression, InstructionInfoProvider, MappingFunction, java.io.Serializable, javax.xml.transform.SourceLocator

public final class ItemChecker
extends UnaryExpression
implements MappingFunction

A ItemChecker implements the item type checking of "treat as": that is, it returns the supplied sequence, checking that all its items are of the correct type

See Also:
  Serialized Form

Field Summary

Fields inherited from class net.sf.saxon.expr.UnaryExpression
`operand`

Fields inherited from class net.sf.saxon.expr.ComputedExpression
`locationId, staticProperties`

Fields inherited from interface net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD`

Constructor Summary
`ItemChecker(Expression sequence, ItemType itemType, RoleLocator role)` Constructor

Method Summary
`Expression` `analyze(StaticContext env, ItemType contextItemType)` Type-check the expression
`protected java.lang.String` `displayOperator(NamePool pool)` Give a string representation of the operator for use in diagnostics
`boolean` `equals(java.lang.Object other)` Is this expression the same as another expression?
`Item` `evaluateItem(XPathContext context)` Evaluate as an Item.
`ItemType` `getItemType()` Determine the data type of the items returned by the expression
`SequenceIterator` `iterate(XPathContext context)` Iterate over the sequence of values
`java.lang.Object` `map(Item item, XPathContext nullcontext, java.lang.Object info)` Mapping function: this is used only if the expression does not allow a sequence of more than one item.
`void` `setErrorCode(java.lang.String code)` Set the error code to be used if the checking fails
`Expression` `simplify(StaticContext env)` Simplify an expression

Methods inherited from class net.sf.saxon.expr.UnaryExpression
`computeCardinality, computeSpecialProperties, display, getBaseExpression, hashCode, iterateSubExpressions, promote`

Methods inherited from class net.sf.saxon.expr.ComputedExpression

`adoptChildExpression, computeDependencies, computeStaticProperties, dynamicError, dynamicError, effectiveBooleanValue, evaluateAsString, getCardinality, getColumnNumber, getConstructType, getDependencies, getExecutable, getImplementationMethod, getInstructionInfo, getIntrinsicDependencies, getLineNumber, getLocationId, getParentExpression, getPublicId, getSpecialProperties, getSystemId, markTailFunctionCalls, process, resetStaticProperties, setLocationId, setParentExpression, typeError`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ItemChecker

    public ItemChecker(Expression sequence,
                       ItemType itemType,
                       RoleLocator role)

  Constructor

Method Detail

### setErrorCode

    public void setErrorCode(java.lang.String code)

  Set the error code to be used if the checking fails

  Parameters:
    `code` - the error code

### simplify

    public Expression simplify(StaticContext env)
                        throws XPathException

  Simplify an expression

  Specified by:
    `simplify` in interface `Expression`
  Overrides:
    `simplify` in class `UnaryExpression`
  Returns:
    the simplified expression
    `XPathException`

### analyze

    public Expression analyze(StaticContext env,
                              ItemType contextItemType)
                       throws XPathException

  Type-check the expression

  Specified by:
    `analyze` in interface `Expression`
  Overrides:
    `analyze` in class `UnaryExpression`
  Parameters:
    `env` - the static context of the expression
    `contextItemType` - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to `Type.ITEM_TYPE`
  Returns:
    the original expression, rewritten to perform necessary run-time type checks, and to perform other type-related optimizations
    `XPathException`

### iterate

    public SequenceIterator iterate(XPathContext context)
                             throws XPathException

  Iterate over the sequence of values

  Specified by:
    `iterate` in interface `Expression`
  Overrides:
    `iterate` in class `ComputedExpression`
  Parameters:
    `context` - supplies the context for evaluation
  Returns:
    a SequenceIterator that can be used to iterate over the result of the expression
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### map

    public java.lang.Object map(Item item,
                                XPathContext nullcontext,
                                java.lang.Object info)
                         throws XPathException

  Mapping function: this is used only if the expression does not allow a sequence of more than one item.

  Specified by:
    `map` in interface `MappingFunction`
  Parameters:
    `item` - The item to be mapped. If context is supplied, this must be the same as context.currentItem().
    `nullcontext` - The processing context. This is supplied only for mapping constructs that set the context node, position, and size. Otherwise it is null.
    `info` - Arbitrary information supplied by the creator of the MappingIterator. It must be read-only and immutable for the duration of the iteration.
  Returns:
    either (a) a SequenceIterator over the sequence of items that the supplied input item maps to, or (b) an Item if it maps to a single item, or (c) null if it maps to an empty sequence.
    `XPathException`

### evaluateItem

    public Item evaluateItem(XPathContext context)
                      throws XPathException

  Evaluate as an Item.

  Specified by:
    `evaluateItem` in interface `Expression`
  Overrides:
    `evaluateItem` in class `ComputedExpression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the node or atomic value that results from evaluating the expression; or null to indicate that the result is an empty sequence
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### getItemType

    public ItemType getItemType()

  Determine the data type of the items returned by the expression

  Specified by:
    `getItemType` in interface `Expression`
  Overrides:
    `getItemType` in class `UnaryExpression`
  Returns:
    the item type of the items in the result sequence, insofar as this is known statically.

### equals

    public boolean equals(java.lang.Object other)

  Is this expression the same as another expression?

  Overrides:
    `equals` in class `UnaryExpression`

### displayOperator

    protected java.lang.String displayOperator(NamePool pool)

  Give a string representation of the operator for use in diagnostics

  Specified by:
    `displayOperator` in class `UnaryExpression`
  Returns:
    the operator, as a string