@Override public int compare(IN o1, IN o2) { return comparator.compare(o1, o2); } });
@Override public int compare(IN2 o1, IN2 o2) { return rightComparator.compare(o1, o2); } });
@Override public int compare(IN o1, IN o2) { return sortComparator.compare(o1, o2); } });
@Override public int compare(IN o1, IN o2) { return sortComparator.compare(o1, o2); } });
@Override public int compare(IN1 o1, IN1 o2) { return leftComparator.compare(o1, o2); } });
@Override public int compare(IN2 o1, IN2 o2) { return inputSortComparator2.compare(o1, o2); } });
@Override public boolean equals(Object o) { if (!(o instanceof TypeComparable)) { return false; } @SuppressWarnings("unchecked") TypeComparable<T> other = (TypeComparable<T>) o; return comparator.compare(elem, other.elem) == 0; } }
@Override public int compare(IN o1, IN o2) { return sortComparator.compare(o1, o2); } });
@Override public int compare(IN1 o1, IN1 o2) { return inputSortComparator1.compare(o1, o2); } });
@Override public int compare(IN o1, IN o2) { return sortComparator.compare(o1, o2); } });
@Override public int compare(T first, T second) { // both values are null -> equality if (first == null && second == null) { return 0; } // first value is null -> inequality // but order is considered else if (first == null) { return order ? -1 : 1; } // second value is null -> inequality // but order is considered else if (second == null) { return order ? 1 : -1; } // no null values else { return wrappedComparator.compare(first, second); } }
private int compareKeys(TypeComparator[] flatComparators, Object[] keys, Object[] boundary) { if (flatComparators.length != keys.length || flatComparators.length != boundary.length) { throw new RuntimeException("Can not compare keys with boundary due to mismatched length."); } for (int i=0; i<flatComparators.length; i++) { int result = flatComparators[i].compare(keys[i], boundary[i]); if (result != 0) { return result; } } return 0; } }
@Override public boolean equalToReference(T2 candidate) { comparator2.extractKeys(candidate, candidateKeyFields, 0); for (int i = 0; i < this.comparators1.length; i++) { if (this.comparators1[i].compare(referenceKeyFields[i], candidateKeyFields[i]) != 0) { return false; } } return true; }
@Override public int compareToReference(T2 candidate) { comparator2.extractKeys(candidate, candidateKeyFields, 0); for (int i = 0; i < this.comparators1.length; i++) { // We reverse ordering here because our "compareToReference" does work in a mirrored // way compared to Comparable.compareTo int res = this.comparators1[i].compare(candidateKeyFields[i], referenceKeyFields[i]); if(res != 0) { return res; } } return 0; } }
@Override public int compare(T first, T second) { int i = 0; for (; i < keyFields.length; i++) { int cmp = comparators[i].compare(accessField(keyFields[i], first), accessField(keyFields[i], second)); if (cmp != 0) { return cmp; } } return 0; }
@Override public int compare(Row first, Row second) { int i = 0; try { for (; i < keyPositions.length; i++) { int keyPos = keyPositions[i]; TypeComparator<Object> comparator = comparators[i]; Object firstElement = first.getField(keyPos); // element can be null Object secondElement = second.getField(keyPos); // element can be null int cmp = comparator.compare(firstElement, secondElement); if (cmp != 0) { return cmp; } } } catch (IndexOutOfBoundsException e) { throw new KeyFieldOutOfBoundsException(keyPositions[i]); } return 0; }
@SuppressWarnings("unchecked") @Override public int compare(T first, T second) { int i = 0; try { for (; i < keyPositions.length; i++) { int keyPos = keyPositions[i]; int cmp = comparators[i].compare(first.getFieldNotNull(keyPos), second.getFieldNotNull(keyPos)); if (cmp != 0) { return cmp; } } return 0; } catch (NullFieldException nfex) { throw new NullKeyFieldException(nfex); } catch (IndexOutOfBoundsException iobex) { throw new KeyFieldOutOfBoundsException(keyPositions[i]); } }
@SuppressWarnings("unchecked") @Override public int compareSerialized(DataInputView firstSource, DataInputView secondSource) throws IOException { if (deserializedFields1 == null) { instantiateDeserializationUtils(); } int i = 0; try { for (; i < serializers.length; i++) { deserializedFields1[i] = serializers[i].deserialize(deserializedFields1[i], firstSource); deserializedFields2[i] = serializers[i].deserialize(deserializedFields2[i], secondSource); } for (i = 0; i < keyPositions.length; i++) { int keyPos = keyPositions[i]; int cmp = comparators[i].compare(deserializedFields1[keyPos], deserializedFields2[keyPos]); if (cmp != 0) { return cmp; } } return 0; } catch (NullPointerException npex) { throw new NullKeyFieldException(keyPositions[i]); } catch (IndexOutOfBoundsException iobex) { throw new KeyFieldOutOfBoundsException(keyPositions[i], iobex); } }
@Test @SuppressWarnings("unchecked") public void testKeyExtraction() { TypeComparator<T> comparator = getComparator(true); T[] data = getSortedData(); for (T value : data) { TypeComparator[] comparators = comparator.getFlatComparators(); Object[] extractedKeys = new Object[comparators.length]; int insertedKeys = comparator.extractKeys(value, extractedKeys, 0); assertTrue(insertedKeys == comparators.length); for (int i = 0; i < insertedKeys; i++) { // check if some keys are null, although this is not supported if (!supportsNullKeys()) { assertNotNull(extractedKeys[i]); } // compare the extracted key with itself as a basic check // if the extracted key corresponds to the comparator assertTrue(comparators[i].compare(extractedKeys[i], extractedKeys[i]) == 0); } } }