## 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, EvaluableItem, SequenceIterable, 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

Nested Class Summary
`static class` `AdjacentTextNodeMerger.AdjacentTextNodeMergingIterator` AdjacentTextNodeMergingIterator is an iterator that eliminates zero-length text nodes and merges adjacent text nodes from the underlying iterator

Field Summary

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

Fields inherited from class net.sf.saxon.expr.Expression
`EVALUATE_METHOD, EVENT_FEED_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, PROCESS_METHOD, PUSH_SELECTION, staticProperties, WATCH_METHOD`

Constructor Summary
`AdjacentTextNodeMerger(Expression p0)`

Method Summary
`int` `computeCardinality()` Determine the static cardinality.
`Expression` `copy()` Copy an 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.
`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.
`void` `process(XPathContext context, int locationId, int options)` Process the instruction, without returning any tail calls
`Expression` `typeCheck(ExpressionVisitor visitor, ItemType contextItemType)` Type-check the expression.

Methods inherited from class net.sf.saxon.expr.UnaryExpression
`computeSpecialProperties, displayOperator, equals, explain, getBaseExpression, hashCode, iterateSubExpressions, optimize, promote, replaceSubExpression, simplify, 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, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, getSystemId, hasLoopingSubexpression, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterateEvents, iterateSameFocusSubExpressions, markTailFunctionCalls, process, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setFlattened, setLocationId, staticTypeCheck, suppressValidation, 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

### typeCheck

    public Expression typeCheck(ExpressionVisitor visitor,
                                ItemType 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`

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

  Specified by:
    `iterate` in interface `SequenceIterable`
  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-2010 Saxonica Limited. All rights reserved.