Class ProcessingInstruction

All Implemented Interfaces:
ExportAgent, Locatable, IdentityComparable, Traceable

public class ProcessingInstruction extends SimpleNodeConstructor
An xsl:processing-instruction element in the stylesheet, or a processing-instruction constructor in a query
  • Constructor Details

    • ProcessingInstruction

      public ProcessingInstruction(Expression name)
      Create an xsl:processing-instruction instruction
      Parameters:
      name - the expression used to compute the name of the generated processing-instruction
  • Method Details

    • getNameExp

      public Expression getNameExp()
    • setNameExp

      public void setNameExp(Expression nameExp)
    • operands

      public Iterable<Operand> operands()
      Description copied from class: Expression
      Get the immediate sub-expressions of this expression, with information about the relationship of each expression to its parent expression.

      If the expression is a Callable, then it is required that the order of the operands returned by this function is the same as the order of arguments supplied to the corresponding call() method.

      Overrides:
      operands in class SimpleNodeConstructor
      Returns:
      an iterator containing the sub-expressions of this expression
    • getInstructionNameCode

      public int getInstructionNameCode()
      Get the name of this instruction for diagnostic and tracing purposes
      Overrides:
      getInstructionNameCode in class Instruction
      Returns:
      the string "xsl:processing-instruction"
    • getItemType

      public ItemType getItemType()
      Description copied from class: Instruction
      Get the item type of the items returned by evaluating this instruction
      Overrides:
      getItemType in class Instruction
      Returns:
      the static item type of the instruction
    • getCardinality

      public int getCardinality()
      Description copied from class: Expression
      Determine the static cardinality of the expression. This establishes how many items there will be in the result of the expression, at compile time (i.e., without actually evaluating the result.
      Overrides:
      getCardinality in class Expression
      Returns:
      one of the values Cardinality.ONE_OR_MORE, Cardinality.ZERO_OR_MORE, Cardinality.EXACTLY_ONE, Cardinality.ZERO_OR_ONE, Cardinality.EMPTY. This default implementation returns ZERO_OR_MORE (which effectively gives no information).
    • copy

      public Expression copy(RebindingMap rebindings)
      Copy an expression. This makes a deep copy.
      Specified by:
      copy in class Expression
      Parameters:
      rebindings - variables to be re-bound
      Returns:
      the copy of the original expression
    • localTypeCheck

      public void localTypeCheck(ExpressionVisitor visitor, ContextItemStaticInfo contextItemType) throws XPathException
      Description copied from class: SimpleNodeConstructor
      Method to perform type-checking specific to the kind of instruction
      Specified by:
      localTypeCheck in class SimpleNodeConstructor
      Parameters:
      visitor - an expression visitor
      contextItemType - the static type of the context item
      Throws:
      XPathException - if a type error is detected
    • getDependencies

      public int getDependencies()
      Description copied from class: Expression
      Determine which aspects of the context the expression depends on. The result is a bitwise-or'ed value composed from constants such as XPathContext.VARIABLES and XPathContext.CURRENT_NODE. The default implementation combines the intrinsic dependencies of this expression with the dependencies of the subexpressions, computed recursively. This is overridden for expressions such as FilterExpression where a subexpression's dependencies are not necessarily inherited by the parent expression.
      Overrides:
      getDependencies in class Expression
      Returns:
      a set of bit-significant flags identifying the dependencies of the expression
    • processValue

      public void processValue(UnicodeString value, Outputter output, XPathContext context) throws XPathException
      Process the value of the node, to create the new node.
      Specified by:
      processValue in class SimpleNodeConstructor
      Parameters:
      value - the string value of the new node
      output - the destination for the result
      context - the dynamic evaluation context
      Throws:
      XPathException - if things go wrong
    • checkContent

      public UnicodeString checkContent(UnicodeString data, XPathContext context) throws XPathException
      Check the content of the node, and adjust it if necessary
      Overrides:
      checkContent in class SimpleNodeConstructor
      Parameters:
      data - the supplied content
      context - the dynamic context
      Returns:
      the original content, unless adjustments are needed
      Throws:
      XPathException - if the content is invalid
    • checkContentXSLT

      public static UnicodeString checkContentXSLT(UnicodeString data)
      Check the content of the node, and adjust it if necessary, using the XSLT rules
      Parameters:
      data - the supplied content
      Returns:
      the original content, unless adjustments are needed
    • checkContentXQuery

      public static UnicodeString checkContentXQuery(UnicodeString data) throws XPathException
      Check the content of the node, and adjust it if necessary, using the XQuery rules
      Parameters:
      data - the supplied content
      Returns:
      the original content, unless adjustments are needed
      Throws:
      XPathException - if the content is invalid
    • evaluateNodeName

      public NodeName evaluateNodeName(XPathContext context) throws XPathException
      Description copied from class: SimpleNodeConstructor
      Run-time method to compute the name of the node being constructed. This is overridden for nodes that have a name. The default implementation returns -1, which is suitable for unnamed nodes such as comments
      Overrides:
      evaluateNodeName in class SimpleNodeConstructor
      Parameters:
      context - the XPath dynamic evaluation context
      Returns:
      the name pool nameCode identifying the name of the constructed node
      Throws:
      XPathException - if any failure occurs
    • checkName

      public String checkName(AtomicValue name, XPathContext context) throws XPathException
      Throws:
      XPathException
    • export

      public void export(ExpressionPresenter out) throws XPathException
      Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
      Specified by:
      export in interface ExportAgent
      Specified by:
      export in class Expression
      Parameters:
      out - the expression presenter used to display the structure
      Throws:
      XPathException - if the export fails, for example if an expression is found that won't work in the target environment.
    • getElaborator

      public Elaborator getElaborator()
      Make an elaborator for this expression
      Overrides:
      getElaborator in class Expression
      Returns:
      a suitable elaborator