net.sf.saxon.functions

## Class Concat

- java.lang.Object
- - net.sf.saxon.expr.Expression
  - - net.sf.saxon.expr.FunctionCall
    - - net.sf.saxon.functions.SystemFunctionCall
      - - net.sf.saxon.functions.Concat

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

      public class Concat
      extends SystemFunctionCall
      implements Callable

  Implementation of the fn:concat() function
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.functions.SystemFunctionCall

      `operation`

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

      `argument`

    - ### 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
    `Concat()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Sequence` | `call(XPathContext context, Sequence[] arguments)` Call the Callable.
    `CharSequence` | `evaluateAsString(XPathContext c)` Evaluate the function in a string context
    `StringValue` | `evaluateItem(XPathContext c)` Evaluate in a general context
    `ExpressionCompiler` | `getExpressionCompiler()` Return the compiler of the Concat expression
    `FunctionItemType` | `getFunctionItemType(TypeHierarchy th)` Get the item type of the function item
    `protected SequenceType` | `getRequiredType(int arg)` Get the required type of the nth argument
    `Iterator<SubExpressionInfo>` | `iterateSubExpressionInfo()` Get the immediate sub-expressions of this expression, with information about the relationship of each expression to its parent expression.
    `void` | `process(XPathContext context)` Process the instruction in push mode.

    - ### Methods inherited from class net.sf.saxon.functions.SystemFunctionCall

      `addContextDocumentArgument, addDocToPathMap, bindStaticContext, checkArguments, computeCardinality, computeSpecialProperties, copy, equalOrNull, equals, getContextNode, getConvertingCallable, getDefaultArgumentNode, getDetails, getErrorCodeForTypeErrors, getImplementationMethod, getItemType, getOperation, makeSystemFunction, optimize, setDetails, useContextItemAsDefault`

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

      `addExternalFunctionCallToPathMap, checkArgumentCount, explain, getArguments, getDisplayName, getExpressionName, getFunctionName, getNumberOfArguments, hashCode, iterateSubExpressions, preEvaluate, promote, replaceSubExpression, setArguments, setFunctionName, simplify, simplifyArguments, toString, typeCheck`

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

      `addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getConstructType, getContainer, getDependencies, getEvaluationMethod, getExecutable, getHostLanguage, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getStreamability, getStreamingAdjunct, getSystemId, getSystemId, hasVariableBinding, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterate, iterateEvents, markTailFunctionCalls, 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

    - #### Concat

          public Concat()

  - ### Method Detail

    - #### getFunctionItemType

          public FunctionItemType getFunctionItemType(TypeHierarchy th)

      Get the item type of the function item
      Overrides:
        `getFunctionItemType` in class `SystemFunctionCall`
      Parameters:
        `th` - the type hierarchy cache
      Returns:
        the function item's type

    - #### call

          public Sequence call(XPathContext context,
                      Sequence[] arguments)
                        throws XPathException

      Description copied from interface: `Callable`
      Call the Callable.
      Specified by:
        `call` in interface `Callable`
      Parameters:
        `context` - the dynamic evaluation context
        `arguments` - the values of the arguments, supplied as Sequences.

        Generally it is advisable, if calling iterate() to process a supplied sequence, to call it only once; if the value is required more than once, it should first be converted to a `GroundedValue` by calling the utility methd SequenceTool.toGroundedValue().

        If the expected value is a single item, the item should be obtained by calling Sequence.head(): it cannot be assumed that the item will be passed as an instance of `Item` or `AtomicValue`.

        It is the caller's responsibility to perform any type conversions required to convert arguments to the type expected by the callee. An exception is where this Callable is explicitly an argument-converting wrapper around the original Callable.

      Returns:
        the result of the evaluation, in the form of a Sequence. It is the responsibility of the callee to ensure that the type of result conforms to the expected result type.
      Throws:
        `XPathException` - if a dynamic error occurs during the evaluation of the expression

    - #### getRequiredType

          protected SequenceType getRequiredType(int arg)

      Get the required type of the nth argument
      Overrides:
        `getRequiredType` in class `SystemFunctionCall`
      Parameters:
        `arg` - the number of the argument whose type is requested, zero-based
      Returns:
        the required type of the argument as defined in the function signature

    - #### iterateSubExpressionInfo

          public Iterator<SubExpressionInfo> iterateSubExpressionInfo()

      Get the immediate sub-expressions of this expression, with information about the relationship of each expression to its parent expression.
      Overrides:
        `iterateSubExpressionInfo` in class `SystemFunctionCall`
      Returns:
        an iterator containing the sub-expressions of this expression

    - #### evaluateAsString

          public CharSequence evaluateAsString(XPathContext c)
                                        throws XPathException

      Evaluate the function in a string context
      Overrides:
        `evaluateAsString` in class `Expression`
      Parameters:
        `c` - The context in which the expression is to be evaluated
      Returns:
        the value of the expression, evaluated in the current context. The expression must return a string or (); if the value of the expression is (), this method returns "".
      Throws:
        `XPathException` - if any dynamic error occurs evaluating the expression

    - #### evaluateItem

          public StringValue evaluateItem(XPathContext c)
                                   throws XPathException

      Evaluate in a general context
      Overrides:
        `evaluateItem` in class `Expression`
      Parameters:
        `c` - 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

    - #### process

          public void process(XPathContext context)
                       throws XPathException

      Process the instruction in push mode. This avoids constructing the concatenated string in memory, instead each argument can be sent straight to the serializer.
      Overrides:
        `process` in class `Expression`
      Parameters:
        `context` - The dynamic context, giving access to the current node, the current variables, etc.
      Throws:
        `XPathException` - if a dynamic error occurs

    - #### getExpressionCompiler

          public ExpressionCompiler getExpressionCompiler()

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

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