Package net.sf.saxon.expr.sort

## Class GenericAtomicComparer

- java.lang.Object
- - net.sf.saxon.expr.sort.GenericAtomicComparer

- All Implemented Interfaces:
    `AtomicComparer`
  Direct Known Subclasses:
    `EquivalenceComparer`

      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 Summary

    Constructors
    Constructor | Description
    --- | ---
    `GenericAtomicComparer​(StringCollator collator, XPathContext conversionContext)` | Create an GenericAtomicComparer

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `int` | `compareAtomicValues​(AtomicValue a, AtomicValue b)` | Compare two AtomicValue objects according to the rules for their data type.
    `boolean` | `comparesEqual​(AtomicValue a, AtomicValue b)` | Compare two AtomicValue objects for equality according to the rules for their data type.
    `boolean` | `equals​(java.lang.Object obj)` |
    `StringCollator` | `getCollator()` | Get the collation used by this AtomicComparer if any
    `XPathContext` | `getContext()` |
    `StringCollator` | `getStringCollator()` | Get the underlying string collator
    `int` | `hashCode()` |
    `static AtomicComparer` | `makeAtomicComparer​(BuiltInAtomicType type0, BuiltInAtomicType type1, StringCollator collator, XPathContext context)` | Factory method to make a GenericAtomicComparer for values of known types
    `GenericAtomicComparer` | `provideContext​(XPathContext context)` | Supply the dynamic context in case this is needed for the comparison
    `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

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

- - ### 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

    - #### 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`

    - #### getContext

          public XPathContext getContext()

    - #### 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`