net.sf.saxon.expr

## Class UntypedSequenceConverter

- java.lang.Object
- - net.sf.saxon.expr.Expression
  - - net.sf.saxon.expr.UnaryExpression
    - - net.sf.saxon.expr.AtomicSequenceConverter
      - - net.sf.saxon.expr.UntypedSequenceConverter

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

      public final class UntypedSequenceConverter
      extends AtomicSequenceConverter

  An UntypedSequenceConverter is an expression that performs a cast on each member of a supplied sequence that is an untypedAtomic value, while leaving other items unchanged
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `UntypedSequenceConverter.UntypedConverter` A Converter that converts untyped atomic values to the required type, while leaving other values unchanged

    - ### Nested classes/interfaces inherited from class net.sf.saxon.expr.AtomicSequenceConverter

      `AtomicSequenceConverter.AtomicSequenceMappingFunction, AtomicSequenceConverter.ToStringMappingFunction`

  - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.expr.AtomicSequenceConverter

      `converter, TO_STRING_MAPPER`

    - ### 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
    `UntypedSequenceConverter(Expression sequence, PlainType requiredItemType)` Constructor

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `computeCardinality()` Determine the static cardinality of the expression
    `int` | `computeSpecialProperties()` Determine the special properties of this expression
    `Expression` | `copy()` Copy an expression.
    `protected String` | `displayOperator(Configuration config)` Give a string representation of the operator for use in diagnostics
    `boolean` | `equals(Object other)` Is this expression the same as another expression?
    `void` | `explain(ExpressionPresenter destination)` Diagnostic print of expression structure.
    `String` | `getExpressionName()` Get a name identifying the kind of expression, in terms meaningful to a user.
    `ItemType` | `getItemType(TypeHierarchy th)` Determine the data type of the items returned by the expression, if possible
    `int` | `hashCode()` get HashCode for comparing two expressions.
    `static UntypedSequenceConverter` | `makeUntypedSequenceConverter(Configuration config, Expression operand, PlainType requiredItemType)` Create an AtomicSequenceConverter that converts all untypedAtomic values in the input sequence to a specified target type, while leaving items other than untypedAtomic unchanged
    `static UntypedSequenceConverter` | `makeUntypedSequenceRejector(Configuration config, Expression operand, PlainType requiredItemType)`
    `Expression` | `typeCheck(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Type-check the expression

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

      `allocateConverter, evaluateItem, getConverter, getExpressionCompiler, getRequiredItemType, getStreamability, getStreamingAdjunct, iterate, optimize, setConverter, simplify`

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

      `getBaseExpression, iterateSubExpressions, promote, replaceSubExpression, toString`

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

      `addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getConstructType, getContainer, getDependencies, getEvaluationMethod, getExecutable, getHostLanguage, getImplementationMethod, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, 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

    - #### UntypedSequenceConverter

          public UntypedSequenceConverter(Expression sequence,
                                  PlainType requiredItemType)

      Constructor
      Parameters:
        `sequence` - this must be a sequence of atomic values. This is not checked; a ClassCastException will occur if the precondition is not satisfied.
        `requiredItemType` - the item type to which all items in the sequence should be converted, using the rules for "cast as".

  - ### Method Detail

    - #### makeUntypedSequenceConverter

          public static UntypedSequenceConverter makeUntypedSequenceConverter(Configuration config,
                                                              Expression operand,
                                                              PlainType requiredItemType)
                                                                       throws XPathException

      Create an AtomicSequenceConverter that converts all untypedAtomic values in the input sequence to a specified target type, while leaving items other than untypedAtomic unchanged
      Parameters:
        `config` - the Saxon configuration
        `operand` - the expression that delivers the input sequence
        `requiredItemType` - the type to which untypedAtomic values should be cast, which must either be an atomic type or a "plain" union type
      Returns:
        an AtomicSequenceConverter that performs the required conversion
      Throws:
        `XPathException` - if an error occurs, for example if the target type is namespace-sensitive

    - #### makeUntypedSequenceRejector

          public static UntypedSequenceConverter makeUntypedSequenceRejector(Configuration config,
                                                             Expression operand,
                                                             PlainType requiredItemType)

    - #### typeCheck

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

      Description copied from class: `AtomicSequenceConverter`
      Type-check the expression
      Overrides:
        `typeCheck` in class `AtomicSequenceConverter`
      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)

    - #### computeSpecialProperties

          public int computeSpecialProperties()

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

    - #### copy

          public Expression copy()

      Copy an expression. This makes a deep copy.
      Overrides:
        `copy` in class `AtomicSequenceConverter`
      Returns:
        the copy of the original expression

    - #### getItemType

          public ItemType getItemType(TypeHierarchy th)

      Determine the data type of the items returned by the expression, if possible
      Overrides:
        `getItemType` in class `AtomicSequenceConverter`
      Parameters:
        `th` - the type hierarchy cache
      Returns:
        a value such as Type.STRING, Type.BOOLEAN, Type.NUMBER, Type.NODE, or Type.ITEM (meaning not known in advance)

    - #### computeCardinality

          public int computeCardinality()

      Determine the static cardinality of the expression
      Overrides:
        `computeCardinality` in class `AtomicSequenceConverter`
      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`

    - #### equals

          public boolean equals(Object other)

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

    - #### hashCode

          public int hashCode()

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

    - #### displayOperator

          protected String displayOperator(Configuration config)

      Description copied from class: `UnaryExpression`
      Give a string representation of the operator for use in diagnostics
      Overrides:
        `displayOperator` in class `AtomicSequenceConverter`
      Parameters:
        `config` - the Saxon configuration
      Returns:
        the operator, as a string

    - #### getExpressionName

          public String getExpressionName()

      Get a name identifying the kind of expression, in terms meaningful to a user.
      Overrides:
        `getExpressionName` in class `AtomicSequenceConverter`
      Returns:
        a name identifying the kind of expression, in terms meaningful to a user. The name will always be in the form of a lexical XML QName, and should match the name used in explain() output displaying the expression.

    - #### explain

          public void explain(ExpressionPresenter destination)

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

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