net.sf.saxon.expr

## Class CastToList

- java.lang.Object
- - net.sf.saxon.expr.Expression
  - - net.sf.saxon.expr.UnaryExpression
    - - net.sf.saxon.expr.CastToList

- All Implemented Interfaces:
    Serializable, SourceLocator, LocationProvider, SaxonLocator, InstructionInfo, Locator

      public class CastToList
      extends UnaryExpression

  Expression class for a cast to a List 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.Expression

      `EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, EVENT_FEED_METHOD, INHERITED_CONTEXT, INSPECTION_CONTEXT, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, NAVIGATION_CONTEXT, NODE_VALUE_CONTEXT, PROCESS_METHOD, PUSH_SELECTION, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, W3C_CONSUMING, W3C_FREE_RANGING, W3C_GROUP_CONSUMING, W3C_MOTIONLESS, WATCH_METHOD`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `CastToList(Expression source, ListType targetType, boolean allowEmpty)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static AtomicSequence` | `cast(CharSequence value, ListType targetType, NamespaceResolver nsResolver, ConversionRules rules)` Cast a string value to a list type
    `int` | `computeCardinality()` Get the static cardinality of the expression
    `int` | `computeSpecialProperties()` Determine the special properties of this expression
    `Expression` | `copy()` Copy an expression.
    `boolean` | `equals(Object other)` Is this expression the same as another expression?
    `void` | `explain(ExpressionPresenter out)` Diagnostic print of expression structure.
    `ExpressionCompiler` | `getExpressionCompiler()` Return the compiler of the CastToList expression
    `ItemType` | `getItemType(TypeHierarchy th)` Get the static type of the expression
    `NamespaceResolver` | `getNamespaceResolver()`
    `ListType` | `getTargetType()`
    `int` | `hashCode()` get HashCode for comparing two expressions.
    `boolean` | `isAllowEmpty()`
    `SequenceIterator` | `iterate(XPathContext context)` Evaluate the expression
    `Expression` | `optimize(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Perform optimisation of an expression and its subexpressions.
    `Expression` | `simplify(ExpressionVisitor visitor)` Simplify the expression
    `String` | `toString()` The toString() method for an expression attempts to give a representation of the expression in an XPath-like form, but there is no guarantee that the syntax will actually be true XPath.
    `Expression` | `typeCheck(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Type-check the expression

    - ### Methods inherited from class net.sf.saxon.expr.UnaryExpression

      `displayOperator, getBaseExpression, iterateSubExpressions, promote, replaceSubExpression`

    - ### Methods inherited from class net.sf.saxon.expr.Expression

      `addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getConstructType, getContainer, getDependencies, getEvaluationMethod, getExecutable, getExpressionName, getHostLanguage, getImplementationMethod, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getStreamability, getStreamingAdjunct, getSystemId, getSystemId, hasVariableBinding, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterateEvents, iterateSubExpressionInfo, markTailFunctionCalls, process, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setFlattened, setLocationId, staticTypeCheck, suppressValidation, toPattern, toStreamingPattern, typeError`

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

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

- - ### Constructor Detail

    - #### CastToList

          public CastToList(Expression source,
                    ListType targetType,
                    boolean allowEmpty)

  - ### Method Detail

    - #### isAllowEmpty

          public boolean isAllowEmpty()

    - #### getTargetType

          public ListType getTargetType()

    - #### getNamespaceResolver

          public NamespaceResolver getNamespaceResolver()

    - #### simplify

          public Expression simplify(ExpressionVisitor visitor)
                              throws XPathException

      Simplify the expression
      Overrides:
        `simplify` in class `UnaryExpression`
      Parameters:
        `visitor` - an expression visitor
      Returns:
        the simplified expression
      Throws:
        `XPathException` - if an error is discovered during expression rewriting

    - #### typeCheck

          public Expression typeCheck(ExpressionVisitor visitor,
                             ExpressionVisitor.ContextItemType contextItemType)
                               throws XPathException

      Type-check the expression
      Overrides:
        `typeCheck` in class `UnaryExpression`
      Parameters:
        `visitor` - an expression visitor
        `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
      Throws:
        `XPathException` - if an error is discovered during this phase (typically a type error)

    - #### optimize

          public Expression optimize(ExpressionVisitor visitor,
                            ExpressionVisitor.ContextItemType contextItemType)
                              throws XPathException

      Perform optimisation of an expression and its subexpressions.

      This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

      Overrides:
        `optimize` in class `UnaryExpression`
      Parameters:
        `visitor` - an expression visitor
        `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 if appropriate to optimize execution
      Throws:
        `XPathException` - if an error is discovered during this phase (typically a type error)

    - #### computeCardinality

          public int computeCardinality()

      Get the static cardinality of the expression
      Overrides:
        `computeCardinality` in class `UnaryExpression`
      Returns:
        the computed cardinality, as one of the values `StaticProperty.ALLOWS_ZERO_OR_ONE`, `StaticProperty.EXACTLY_ONE`, `StaticProperty.ALLOWS_ONE_OR_MORE`, `StaticProperty.ALLOWS_ZERO_OR_MORE`

    - #### getItemType

          public ItemType getItemType(TypeHierarchy th)

      Get the static type of the expression
      Overrides:
        `getItemType` in class `UnaryExpression`
      Parameters:
        `th` - the type hierarchy cache
      Returns:
        the item type of the items in the result sequence, insofar as this is known statically.

    - #### computeSpecialProperties

          public int computeSpecialProperties()

      Determine the special properties of this expression
      Overrides:
        `computeSpecialProperties` in class `UnaryExpression`
      Returns:
        `StaticProperty.NON_CREATIVE`.

    - #### copy

          public Expression copy()

      Copy an expression. This makes a deep copy.
      Specified by:
        `copy` in class `Expression`
      Returns:
        the copy of the original expression

    - #### iterate

          public SequenceIterator iterate(XPathContext context)
                                   throws XPathException

      Evaluate the expression
      Overrides:
        `iterate` in class `Expression`
      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

    - #### cast

          public static AtomicSequence cast(CharSequence value,
                            ListType targetType,
                            NamespaceResolver nsResolver,
                            ConversionRules rules)
                                     throws XPathException

      Cast a string value to a list type
      Parameters:
        `value` - the input string value
        `targetType` - the target list type
        `nsResolver` - the namespace context, needed if the type is namespace-sensitive
        `rules` - the conversion rules
      Returns:
        the sequence of atomic values that results from the conversion
      Throws:
        `XPathException` - if the conversion fails

    - #### equals

          public boolean equals(Object other)

      Is this expression the same as another expression?
      Overrides:
        `equals` in class `UnaryExpression`

    - #### hashCode

          public int hashCode()

      get HashCode for comparing two expressions.
      Overrides:
        `hashCode` in class `UnaryExpression`

    - #### getExpressionCompiler

          public ExpressionCompiler getExpressionCompiler()

      Return the compiler of the CastToList expression
      Overrides:
        `getExpressionCompiler` in class `Expression`
      Returns:
        the relevant ExpressionCompiler

    - #### toString

          public String toString()

      The toString() method for an expression attempts to give a representation of the expression in an XPath-like form, but there is no guarantee that the syntax will actually be true XPath. In the case of XSLT instructions, the toString() method gives an abstracted view of the syntax
      Overrides:
        `toString` in class `UnaryExpression`
      Returns:
        a representation of the expression as a string

    - #### explain

          public void explain(ExpressionPresenter out)

      Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
      Overrides:
        `explain` in class `UnaryExpression`
      Parameters:
        `out` - the expression presenter used to display the structure

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