Class DoubleSortComparer

  • All Implemented Interfaces:

    public class DoubleSortComparer
    extends java.lang.Object
    implements AtomicComparer
    An AtomicComparer used for sorting values that are known to be numeric. It also supports a separate method for getting a collation key to test equality of items. This comparator treats NaN values as equal to each other, and less than any other value.
    • Method Detail

      • getInstance

        public static DoubleSortComparer getInstance()
        Get the singular instance of this class
        the singular instance
      • getCollator

        public StringCollator getCollator()
        Description copied from interface: AtomicComparer
        Get the collation used by this AtomicComparer if any
        Specified by:
        getCollator in interface AtomicComparer
        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
        context - the dynamic evaluation context
        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)
        Compare two AtomicValue objects according to the rules for their data type.
        Specified by:
        compareAtomicValues in interface AtomicComparer
        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.
        <0 if a<b, 0 if a=b, >0 if a>b
        java.lang.ClassCastException - if the objects are not comparable
      • comparesEqual

        public boolean comparesEqual​(AtomicValue a,
                                     AtomicValue b)
        Test whether two values compare equal. Note that for this comparer, NaN is considered equal to itself
        Specified by:
        comparesEqual in interface AtomicComparer
        a - the first object to be compared.
        b - the second object to be compared.
        true if the values are equal, false if not
      • save

        public java.lang.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
        a string representation of the AtomicComparer