/**
* Sorts the receiver according to the order induced by the specified comparator. All elements in
* the range must be <i>mutually comparable</i> by the specified comparator (that is,
* <tt>c.compare(e1, e2)</tt> must not throw a <tt>ClassCastException</tt> for any elements
* <tt>e1</tt> and <tt>e2</tt> in the range).
*
* <p>The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas
* McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P.
* 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that
* cause other quicksorts to degrade to quadratic performance.
*
* @param from the index of the first element (inclusive) to be sorted.
* @param to the index of the last element (inclusive) to be sorted.
* @param c the comparator to determine the order of the receiver.
* @throws ClassCastException if the array contains elements that are not <i>mutually
* comparable</i> using the specified comparator.
* @throws IllegalArgumentException if <tt>fromIndex > toIndex</tt>
* @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or <tt>toIndex >
* a.length</tt>
* @see Comparator
* @exception IndexOutOfBoundsException index is out of range ( <tt>size()>0 && (from<0 ||
* from>to || to>=size())</tt> ).
*/
public void quickSortFromTo(int from, int to, UuidComparatorBI c) {
int mySize = size();
checkRangeFromTo(from, to, mySize);
long[] myElements = elements();
UuidSorting.quickSort(myElements, from, to + 1, c);
elements(myElements);
setSizeRaw(mySize);
}
/**
* Sorts the specified range of the receiver into ascending order.
*
* <p>The sorting algorithm is a modified mergesort (in which the merge is omitted if the highest
* element in the low sublist is less than the lowest element in the high sublist). This algorithm
* offers guaranteed n*log(n) performance, and can approach linear performance on nearly sorted
* lists.
*
* <p><b>You should never call this method unless you are sure that this particular sorting
* algorithm is the right one for your data set.</b> It is generally better to call
* <tt>sort()</tt> or <tt>sortFromTo(...)</tt> instead, because those methods automatically choose
* the best sorting algorithm.
*
* @param from the index of the first element (inclusive) to be sorted.
* @param to the index of the last element (inclusive) to be sorted.
* @exception IndexOutOfBoundsException index is out of range ( <tt>size()>0 && (from<0 ||
* from>to || to>=size())</tt> ).
*/
@Override
public void mergeSortFromTo(int from, int to) {
int mySize = size();
checkRangeFromTo(from, to, mySize);
long[] myElements = elements();
Sorting.mergeSort(myElements, from, to + 1);
elements(myElements);
setSizeRaw(mySize);
}