Package net.sf.saxon.expr

Class Literal.LiteralElaborator

  • Enclosing class:
    Literal
    public static class Literal.LiteralElaborator
extends PullElaborator
    Elaborator for a literal.

    Evaluators are supplied for evaluation in pull, push, and singleton mode, as well as boolean evaluation

    • Constructor Detail

      • LiteralElaborator

        public LiteralElaborator()

    • Method Detail

      • eagerly

        public SequenceEvaluator eagerly()
        Description copied from class: Elaborator
        Get a function that evaluates the underlying expression eagerly
        Overrides:
        eagerly in class PullElaborator
        Returns:
        an evaluator for the expression that returns a GroundedValue. The class SequenceEvaluator is declared to return a Sequence not a GroundedValue; we can't specialize it because it's a limitation of C# delegates, but the result can safely be cast to GroundedValue.

      • lazily

        public SequenceEvaluator lazily​(boolean repeatable,
                                boolean lazyEvaluationRequired)
        Description copied from class: Elaborator
        Get a function that evaluates the underlying expression lazily
        Overrides:
        lazily in class Elaborator
        Parameters:
        repeatable - true if the resulting Sequence must be usable repeatedly; false if it only needs to be used once
        lazyEvaluationRequired - true if the expression MUST be evaluated lazily, for example to prevent spurious errors or side-effects if it has been lifted out of a loop
        Returns:
        an evaluator for the expression that returns a Sequence (which may be a lazy sequence)

      • elaborateForPush

        public PushEvaluator elaborateForPush()
        Description copied from class: Elaborator
        Get a function that evaluates the underlying expression in push mode, by writing events to an Outputter
        Overrides:
        elaborateForPush in class PullElaborator
        Returns:
        an evaluator for the expression in push mode

      • elaborateForItem

        public ItemEvaluator elaborateForItem()
        Description copied from class: Elaborator
        Get a function that evaluates the underlying expression in the form of a Item. This must only be called for expressions whose result has cardinality zero or one.
        Overrides:
        elaborateForItem in class PullElaborator
        Returns:
        an evaluator for the expression that returns an Item, or null to represent an empty sequence.

      • elaborateForBoolean

        public BooleanEvaluator elaborateForBoolean()
        Description copied from class: Elaborator
        Get a function that evaluates the underlying expression in the form of a boolean, this being the effective boolean value of the expression.
        Overrides:
        elaborateForBoolean in class PullElaborator
        Returns:
        an evaluator for the expression that returns a boolean.

      • elaborateForUnicodeString

        public UnicodeStringEvaluator elaborateForUnicodeString​(boolean zeroLengthWhenAbsent)
        Description copied from class: Elaborator
        Get a function that evaluates the underlying expression in the form of a unicode string, this being the result of applying fn:string() to the result of the expression.
        Overrides:
        elaborateForUnicodeString in class PullElaborator
        Parameters:
        zeroLengthWhenAbsent - if true, then when the result of the expression is an empty sequence, the result of the StringEvaluator should be a zero-length string. If false, the return value should be null. For an expression or function that never returns an empty sequence (for example, a call on string() or normalize-space()), the argument has no effect.
        Returns:
        an evaluator for the expression that returns a string.

      • elaborateForString

        public StringEvaluator elaborateForString​(boolean zeroLengthWhenAbsent)
        Description copied from class: Elaborator
        Get a function that evaluates the underlying expression in the form of a Java string, this being the result of applying fn:string() to the result of the expression.
        Overrides:
        elaborateForString in class Elaborator
        Parameters:
        zeroLengthWhenAbsent - if true, then when the result of the expression is an empty sequence, the result of the StringEvaluator should be a zero-length string. If false, the return value should be null.
        Returns:
        an evaluator for the expression that returns a string.