Package net.sf.saxon.expr.sort

Class EmptyGreatestComparer

  • All Implemented Interfaces:
    AtomicComparer
    public class EmptyGreatestComparer
extends Object
implements AtomicComparer
    A Comparer that modifies a base comparer by sorting empty key values and NaN values last (greatest), as opposed to the default which sorts them first.

    • Constructor Detail

      • EmptyGreatestComparer

        public EmptyGreatestComparer​(AtomicComparer baseComparer)
        Create an EmptyGreatestComparer
        Parameters:
        baseComparer - the comparer used to compare non-empty values (which typically sorts empty as least)

    • Method Detail

      • getBaseComparer

        public AtomicComparer getBaseComparer()
        Get the underlying comparer (which compares empty least)
        Returns:
        the base comparer

      • getCollator

        public StringCollator getCollator()
        Description copied from interface: AtomicComparer
        Get the collation used by this AtomicComparer if any
        Specified by:
        getCollator in interface AtomicComparer
        Returns:
        the collation used for comparing strings, or null if not applicable

      • provideContext

        public AtomicComparer provideContext​(XPathContext context)
        Supply the dynamic context in case this is needed for the comparison
        Specified by:
        provideContext in interface AtomicComparer
        Parameters:
        context - the dynamic evaluation context
        Returns:
        either the original AtomicComparer, or a new AtomicComparer in which the context is known. The original AtomicComparer is not modified

      • compareAtomicValues

        public int compareAtomicValues​(AtomicValue a,
                               AtomicValue b)
                        throws NoDynamicContextException
        Compare two AtomicValue objects according to the rules for their data type. UntypedAtomic values are compared as if they were strings; if different semantics are wanted, the conversion must be done by the caller.
        Specified by:
        compareAtomicValues in interface AtomicComparer
        Parameters:
        a - the first object to be compared. It is intended that this should normally be an instance of AtomicValue, though this restriction is not enforced. If it is a StringValue, the collator is used to compare the values, otherwise the value must implement the java.util.Comparable interface.
        b - the second object to be compared. This must be comparable with the first object: for example, if one is a string, they must both be strings.
        Returns:
        <0 if a<b, 0 if a=b, >0 if a>b
        Throws:
        ClassCastException - if the objects are not comparable
        NoDynamicContextException - if this comparer required access to dynamic context information, notably the implicit timezone, and this information is not available. In general this happens if a context-dependent comparison is attempted at compile-time, and it signals the compiler to generate code that tries again at run-time.

      • save

        public String save()
        Create a string representation of this AtomicComparer that can be saved in a compiled package and used to reconstitute the AtomicComparer when the package is reloaded
        Specified by:
        save in interface AtomicComparer
        Returns:
        a string representation of the AtomicComparer