@Override @SuppressWarnings("unchecked") public K getKey(IN value) throws Exception { comparator.extractKeys(value, keyArray, 0); return (K) keyArray[0]; } }
@Override public void setReference(T1 reference) { comparator1.extractKeys(reference, referenceKeyFields, 0); }
@Override public int extractKeys(Object record, Object[] target, int index) { if (record == null) { for (int i = 0; i < flatFields; i++) { target[index + i] = null; } return flatFields; } else { return wrappedComparator.extractKeys(record, target, index); } }
@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 extractKeys(Object record, Object[] target, int index) { int localIndex = index; for (int i = 0; i < comparators.length; i++) { localIndex += comparators[i].extractKeys(accessField(keyFields[i], record), target, localIndex); } return localIndex - index; }
@Override public int extractKeys(Object record, Object[] target, int index) { int localIndex = index; for(int i = 0; i < comparators.length; i++) { localIndex += comparators[i].extractKeys(((Tuple) record).getField(keyPositions[i]), target, localIndex); } return localIndex - index; }
@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; } }
private int binarySearch(T record) { int low = 0; int high = this.boundaries.length - 1; typeComparator.extractKeys(record, keys, 0); while (low <= high) { final int mid = (low + high) >>> 1; final int result = compareKeys(flatComparators, keys, this.boundaries[mid]); if (result > 0) { low = mid + 1; } else if (result < 0) { high = mid - 1; } else { return mid; } } // key not found, but the low index is the target // bucket, since the boundaries are the upper bound return low; }
@Override public Tuple getKey(IN value) { Tuple key = Tuple.newInstance(keyLength); comparator.extractKeys(value, keyArray, 0); for (int i = 0; i < keyLength; i++) { key.setField(keyArray[i], i); } return key; }
@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); } } }
@Override @SuppressWarnings("unchecked") public K getKey(IN value) throws Exception { comparator.extractKeys(value, keyArray, 0); return (K) keyArray[0]; } }
@Override @SuppressWarnings("unchecked") public K getKey(IN value) throws Exception { comparator.extractKeys(value, keyArray, 0); return (K) keyArray[0]; } }
@Override public int extractKeys(Object record, Object[] target, int index) { if (record == null) { for (int i = 0; i < flatFields; i++) { target[index + i] = null; } return flatFields; } else { return wrappedComparator.extractKeys(record, target, index); } }
@Override public int extractKeys(Object record, Object[] target, int index) { int localIndex = index; for (int i = 0; i < comparators.length; i++) { localIndex += comparators[i].extractKeys(accessField(keyFields[i], record), target, localIndex); } return localIndex - index; }
@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 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 extractKeys(Object record, Object[] target, int index) { int localIndex = index; for(int i = 0; i < comparators.length; i++) { localIndex += comparators[i].extractKeys(((Tuple) record).getField(keyPositions[i]), target, localIndex); } return localIndex - index; }
@Override public int extractKeys(Object record, Object[] target, int index) { int localIndex = index; for(int i = 0; i < comparators.length; i++) { localIndex += comparators[i].extractKeys(((Tuple) record).getObject(keyPositions[i]), target, localIndex); } return localIndex - index; }
@Override public Tuple getKey(IN value) throws Exception { Tuple key = Tuple.getTupleClass(keyLength).newInstance(); comparator.extractKeys(value, keyArray, 0); for (int i = 0; i < keyLength; i++) { key.setField(keyArray[i], i); } return key; }
@Override public int extractKeys(Object record, Object[] target, int index) { if(!areKeysAbs) { makeKeysAbs(keyPositions, ((Tuple)record).size()); areKeysAbs = true; } int localIndex = index; for(int i = 0; i < comparators.length; i++) { localIndex += comparators[i].extractKeys(((Tuple) record).getObject(keyPositions[i]), target, localIndex); } return localIndex - index; }