Class FixedElement

    • Field Detail

      • namespaceBindings

        protected NamespaceMap namespaceBindings
    • Constructor Detail

      • FixedElement

        public FixedElement​(NodeName elementName,
                            NamespaceMap namespaceBindings,
                            boolean inheritNamespacesToChildren,
                            boolean inheritNamespacesFromParent,
                            SchemaType schemaType,
                            int validation)
        Create an instruction that creates a new element node
        elementName - Represents the name of the element node
        namespaceBindings - List of namespaces to be added to the element node. Supply an empty array if none are required.
        inheritNamespacesToChildren - true if the children of this element inherit its namespaces
        inheritNamespacesFromParent - true if this element inherits namespaces from its parent
        schemaType - Type annotation for the new element node
        validation - Validation mode to be applied, for example STRICT, LAX, SKIP
    • Method Detail

      • setLocation

        public void setLocation​(Location id)
        Description copied from class: Expression
        Set the location on an expression.
        setLocation in class Expression
        id - the location
      • operands

        public java.lang.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.

        Specified by:
        operands in class Instruction
        an iterator containing the sub-expressions of this expression
      • simplify

        public Expression simplify()
                            throws XPathException
        Simplify an expression. This performs any context-independent rewriting
        simplify in class Expression
        the simplified expression (or the original if unchanged, or if modified in-situ)
        XPathException - if an error is discovered during expression rewriting
      • checkContentSequence

        protected void checkContentSequence​(StaticContext env)
                                     throws XPathException
        Check statically whether the content of the element creates attributes or namespaces after creating any child nodes
        checkContentSequence in class ElementCreator
        env - the static context
        XPathException - if the content sequence is invalid
      • optimize

        public Expression optimize​(ExpressionVisitor visitor,
                                   ContextItemStaticInfo contextItemType)
                            throws XPathException
        Description copied from class: Expression
        Perform optimisation of an expression and its subexpressions. This is the third and final phase of static optimization.

        This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

        optimize in class ParentNodeConstructor
        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
        the original expression, rewritten if appropriate to optimize execution
        XPathException - if an error is discovered during this phase (typically a type error)
      • copy

        public Expression copy​(RebindingMap rebindings)
        Copy an expression. This makes a deep copy.
        Specified by:
        copy in class Expression
        rebindings - a mutable list of (old binding, new binding) pairs that is used to update the bindings held in any local variable references that are copied.
        the copy of the original expression
      • getItemType

        public ItemType getItemType()
        Get the type of the item returned by this instruction
        getItemType in class ElementCreator
        the item type
      • getFixedElementName

        public NodeName getFixedElementName()
      • gatherProperties

        public void gatherProperties​(java.util.function.BiConsumer<java.lang.String,​java.lang.Object> consumer)
        Get the properties of this object to be included in trace messages, by supplying the property values to a supplied consumer function
        consumer - the function to which the properties should be supplied, as (property name, value) pairs.
      • checkPermittedContents

        public void checkPermittedContents​(SchemaType parentType,
                                           boolean whole)
                                    throws XPathException
        Check that any elements and attributes constructed or returned by this expression are acceptable in the content model of a given complex type. It's always OK to say yes, since the check will be repeated at run-time. The process of checking element and attribute constructors against the content model of a complex type also registers the type of content expected of those constructors, so the static validation can continue recursively.
        checkPermittedContents in class Expression
        parentType - the "given complex type": the method is checking that the nodes returned by this expression are acceptable members of the content model of this type
        whole - if true, we want to check that the value of this expression satisfies the content model as a whole; if false we want to check that the value of the expression is acceptable as one part of the content
        XPathException - if the value delivered by this expression cannot be part of the content model of the given type
      • getActiveNamespaces

        public NamespaceMap getActiveNamespaces()
        Callback to get a list of the intrinsic namespaces that need to be generated for the element.
        the namespace bindings that must be generated for the new element node
      • 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
        out - the expression presenter used to display the structure
        XPathException - if the export fails, for example if an expression is found that won't work in the target environment.
      • toString

        public java.lang.String toString()
        Description copied from class: Expression

        The toString() method for an expression attempts to give a representation of the expression in an XPath-like form.

        For subclasses of Expression that represent XPath expressions, the result should always be a string that parses as an XPath 3.0 expression. The expression produced should be equivalent to the original making certain assumptions about the static context. In general the expansion will make no assumptions about namespace bindings, except that (a) the prefix "xs" is used to refer to the XML Schema namespace, and (b) the default function namespace is assumed to be the "fn" namespace.

        In the case of XSLT instructions and XQuery expressions, the toString() method gives an abstracted view of the syntax that is not designed in general to be parseable.

        toString in class Expression
        a representation of the expression as a string
      • toShortString

        public java.lang.String toShortString()
        Description copied from class: Expression
        Produce a short string identifying the expression for use in error messages
        toShortString in class Expression
        a short string, sufficient to identify the expression
      • getExpressionName

        public java.lang.String getExpressionName()
        Get a name identifying the kind of expression, in terms meaningful to a user.
        getExpressionName in class Instruction
        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.
      • getElaborator

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