Class GenericAtomicComparer

  • All Implemented Interfaces:
    AtomicComparer
    Direct Known Subclasses:
    SwitchCaseComparer

    public class GenericAtomicComparer
    extends java.lang.Object
    implements AtomicComparer
    An AtomicComparer used for comparing atomic values of arbitrary item types. It encapsulates a Collator that is used when the values to be compared are strings. It also supports a separate method for testing equality of items, which can be used for data types that are not ordered.
    • Constructor Detail

      • GenericAtomicComparer

        public GenericAtomicComparer​(StringCollator collator,
                                     XPathContext conversionContext)
        Create an GenericAtomicComparer
        Parameters:
        collator - the collation to be used
        conversionContext - a context, used when converting untyped atomic values to the target type.
    • Method Detail

      • makeAtomicComparer

        public static AtomicComparer makeAtomicComparer​(BuiltInAtomicType type0,
                                                        BuiltInAtomicType type1,
                                                        StringCollator collator,
                                                        XPathContext context)
        Factory method to make a GenericAtomicComparer for values of known types
        Parameters:
        type0 - primitive type of the first operand
        type1 - primitive type of the second operand
        collator - the collation to be used, if any. This is supplied as a SimpleCollation object which encapsulated both the collation URI and the collation itself.
        context - the dynamic context
        Returns:
        a GenericAtomicComparer for values of known types
      • makeAtomicComparisonFunction

        public static GenericAtomicComparer.AtomicComparisonFunction makeAtomicComparisonFunction​(BuiltInAtomicType type0,
                                                                                                  BuiltInAtomicType type1,
                                                                                                  StringCollator collator,
                                                                                                  int operator,
                                                                                                  boolean allowRecursion,
                                                                                                  int version)
        Factory method to make a ComparisonFunction for values of known types
        Parameters:
        type0 - primitive type of the first operand
        type1 - primitive type of the second operand
        collator - the collation to be used, if any. This is supplied as a SimpleCollation object which encapsulated both the collation URI and the collation itself.
        operator - the comparison operator, fpr example Token.FEQ
        allowRecursion - flag to stop infinite recursion (the function recurses if the static types are not known; it then relies on testing the run-time types)
        Returns:
        a comparison function for two atomic values (neither of which may be null)
      • 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 GenericAtomicComparer 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
      • getStringCollator

        public StringCollator getStringCollator()
        Get the underlying string collator
        Returns:
        the string collator
      • 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 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:
        java.lang.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.
      • comparesEqual

        public boolean comparesEqual​(AtomicValue a,
                                     AtomicValue b)
                              throws NoDynamicContextException
        Compare two AtomicValue objects for equality 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:
        comparesEqual in interface AtomicComparer
        Parameters:
        a - the first object to be compared. If it is a StringValue, the collator is used to compare the values, otherwise the value must implement the equals() method.
        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:
        true if the values are equal, false if not
        Throws:
        java.lang.ClassCastException - if the objects are not comparable
        NoDynamicContextException - if no dynamic context has been supplied, and a dynamic context is needed (for example, because the comparison uses the implicit timezone)
      • 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
        Returns:
        a string representation of the AtomicComparer
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class java.lang.Object
      • equals

        public boolean equals​(java.lang.Object obj)
        Overrides:
        equals in class java.lang.Object