net.sf.saxon.expr

## Class AdjacentTextNodeMerger

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

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

      public class AdjacentTextNodeMerger
      extends UnaryExpression

  This class performs the first phase of processing in "constructing simple content": it takes an input sequence, eliminates empty text nodes, and combines adjacent text nodes into one.
  Since:
    9.3
  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
    `AdjacentTextNodeMerger(Expression p0)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `computeCardinality()` Determine the static cardinality.
    `Expression` | `copy()` Copy an expression.
    `ExpressionCompiler` | `getExpressionCompiler()` Return the compiler relating to a particular expression
    `String` | `getExpressionName()` Get a name identifying the kind of expression, in terms meaningful to a user.
    `int` | `getImplementationMethod()` An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
    `ItemType` | `getItemType(TypeHierarchy th)` Determine the data type of the expression, if possible.
    `int` | `getStreamability(int syntacticContext, boolean allowExtensions, List<String> reasons)` Get the "sweep" of this expression as defined in the W3C streamability specifications.
    `AdjacentTextNodeMergerAdjunct` | `getStreamingAdjunct()` Get a class that supports streamed evaluation of this expression
    `static boolean` | `isTextNode(Item item)` Ask whether an item is a text node
    `SequenceIterator` | `iterate(XPathContext context)` Return an Iterator to iterate over the values of a sequence.
    `static Expression` | `makeAdjacentTextNodeMerger(Expression base)` Make an AdjacentTextNodeMerger expression with a given operand, or a simpler equivalent expression if appropriate
    `void` | `process(XPathContext context, int locationId, int options)` Process the instruction, without returning any tail calls
    `Expression` | `simplify(ExpressionVisitor visitor)` Simplify an expression
    `Expression` | `typeCheck(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Type-check the expression.

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

      `computeSpecialProperties, displayOperator, equals, explain, getBaseExpression, hashCode, iterateSubExpressions, optimize, promote, replaceSubExpression, toString`

    - ### 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, getHostLanguage, 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

    - #### AdjacentTextNodeMerger

          public AdjacentTextNodeMerger(Expression p0)

  - ### Method Detail

    - #### makeAdjacentTextNodeMerger

          public static Expression makeAdjacentTextNodeMerger(Expression base)

      Make an AdjacentTextNodeMerger expression with a given operand, or a simpler equivalent expression if appropriate
      Parameters:
        `base` - the operand expression
      Returns:
        an AdjacentTextNodeMerger or equivalent expression

    - #### simplify

          public Expression simplify(ExpressionVisitor visitor)
                              throws XPathException

      Description copied from class: `UnaryExpression`
      Simplify an 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

      Description copied from class: `UnaryExpression`
      Type-check the expression. Default implementation for unary operators that accept any kind of operand
      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)

    - #### getItemType

          public ItemType getItemType(TypeHierarchy th)

      Determine the data type of the expression, if possible. The default implementation for unary expressions returns the item type of the operand
      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.

    - #### computeCardinality

          public int computeCardinality()

      Description copied from class: `UnaryExpression`
      Determine the static cardinality. Default implementation returns the cardinality of the operand
      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`

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

    - #### getImplementationMethod

          public int getImplementationMethod()

      An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process(). This method indicates which of these methods is prefered.
      Overrides:
        `getImplementationMethod` in class `Expression`
      Returns:
        the implementation method, for example `Expression.ITERATE_METHOD` or `Expression.EVALUATE_METHOD` or `Expression.PROCESS_METHOD`

    - #### getExpressionCompiler

          public ExpressionCompiler getExpressionCompiler()

      Description copied from class: `Expression`
      Return the compiler relating to a particular expression
      Overrides:
        `getExpressionCompiler` in class `Expression`
      Returns:
        the relevant ExpressionCompiler

    - #### getStreamability

          public int getStreamability(int syntacticContext,
                             boolean allowExtensions,
                             List<String> reasons)

      Description copied from class: `Expression`
      Get the "sweep" of this expression as defined in the W3C streamability specifications. This provides an assessment of stylesheet code against the W3C criteria for guaranteed streamability, and is implemented to allow these criteria to be tested. It is not the case that all expression that emerge as streamable from this analysis are currently capable of being streamed by Saxon
      Overrides:
        `getStreamability` in class `Expression`
      Parameters:
        `syntacticContext` - one of the values `Expression.NAVIGATION_CONTEXT`, `Expression.NODE_VALUE_CONTEXT`, `Expression.INHERITED_CONTEXT`, `Expression.INSPECTION_CONTEXT`
        `allowExtensions` - if false, the definition of "guaranteed streamability" in the W3C specification is used. If true, Saxon extensions are permitted, which make some
        `reasons` - the caller may supply a list, in which case the implementation may add to this list a message explaining why the construct is not streamable, suitable for inclusion in an error message.
      Returns:
        one of the values `Expression.W3C_MOTIONLESS`, `Expression.W3C_CONSUMING`, `Expression.W3C_GROUP_CONSUMING`, `Expression.W3C_FREE_RANGING`

    - #### getStreamingAdjunct

          public AdjacentTextNodeMergerAdjunct getStreamingAdjunct()

      Description copied from class: `Expression`
      Get a class that supports streamed evaluation of this expression
      Overrides:
        `getStreamingAdjunct` in class `Expression`
      Returns:
        the relevant StreamingAdjunct, or null if none is available

    - #### iterate

          public SequenceIterator iterate(XPathContext context)
                                   throws XPathException

      Return an Iterator to iterate over the values of a sequence. The value of every expression can be regarded as a sequence, so this method is supported for all expressions. This default implementation handles iteration for expressions that return singleton values: for non-singleton expressions, the subclass must provide its own implementation.
      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

    - #### process

          public void process(XPathContext context,
                     int locationId,
                     int options)
                       throws XPathException

      Process the instruction, without returning any tail calls
      Parameters:
        `context` - The dynamic context, giving access to the current node, the current variables, etc.
      Throws:
        `XPathException`

    - #### getExpressionName

          public String getExpressionName()

      Description copied from class: `Expression`
      Get a name identifying the kind of expression, in terms meaningful to a user.
      Overrides:
        `getExpressionName` in class `Expression`
      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.

    - #### isTextNode

          public static boolean isTextNode(Item item)

      Ask whether an item is a text node
      Parameters:
        `item` - the item in question
      Returns:
        true if the item is a node of kind text

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