How to use

reverse

method

in

org.apache.lucene.util.TimSorter

@Override
void doRotate(int lo, int mid, int hi) {
 final int len1 = mid - lo;
 final int len2 = hi - mid;
 if (len1 == len2) {
  while (mid < hi) {
   swap(lo++, mid++);
  }
 } else if (len2 < len1 && len2 <= maxTempSlots) {
  save(mid, len2);
  for (int i = lo + len1 - 1, j = hi - 1; i >= lo; --i, --j) {
   copy(i, j);
  }
  for (int i = 0, j = lo; i < len2; ++i, ++j) {
   restore(i, j);
  }
 } else if (len1 <= maxTempSlots) {
  save(lo, len1);
  for (int i = mid, j = lo; i < hi; ++i, ++j) {
   copy(i, j);
  }
  for (int i = 0, j = lo + len2; j < hi; ++i, ++j) {
   restore(i, j);
  }
 } else {
  reverse(lo, mid);
  reverse(mid, hi);
  reverse(lo, hi);
 }
}

/** Compute the length of the next run, make the run sorted and return its
 *  length. */
int nextRun() {
 final int runBase = runEnd(0);
 assert runBase < to;
 if (runBase == to - 1) {
  return 1;
 }
 int o = runBase + 2;
 if (compare(runBase, runBase+1) > 0) {
  // run must be strictly descending
  while (o < to && compare(o - 1, o) > 0) {
   ++o;
  }
  reverse(runBase, o);
 } else {
  // run must be non-descending
  while (o < to && compare(o - 1, o) <= 0) {
   ++o;
  }
 }
 final int runHi = Math.max(o, Math.min(to, runBase + minRun));
 binarySort(runBase, runHi, o);
 return runHi - runBase;
}

@Override
void doRotate(int lo, int mid, int hi) {
 final int len1 = mid - lo;
 final int len2 = hi - mid;
 if (len1 == len2) {
  while (mid < hi) {
   swap(lo++, mid++);
  }
 } else if (len2 < len1 && len2 <= maxTempSlots) {
  save(mid, len2);
  for (int i = lo + len1 - 1, j = hi - 1; i >= lo; --i, --j) {
   copy(i, j);
  }
  for (int i = 0, j = lo; i < len2; ++i, ++j) {
   restore(i, j);
  }
 } else if (len1 <= maxTempSlots) {
  save(lo, len1);
  for (int i = mid, j = lo; i < hi; ++i, ++j) {
   copy(i, j);
  }
  for (int i = 0, j = lo + len2; j < hi; ++i, ++j) {
   restore(i, j);
  }
 } else {
  reverse(lo, mid);
  reverse(mid, hi);
  reverse(lo, hi);
 }
}

@Override
void doRotate(int lo, int mid, int hi) {
 final int len1 = mid - lo;
 final int len2 = hi - mid;
 if (len1 == len2) {
  while (mid < hi) {
   swap(lo++, mid++);
  }
 } else if (len2 < len1 && len2 <= maxTempSlots) {
  save(mid, len2);
  for (int i = lo + len1 - 1, j = hi - 1; i >= lo; --i, --j) {
   copy(i, j);
  }
  for (int i = 0, j = lo; i < len2; ++i, ++j) {
   restore(i, j);
  }
 } else if (len1 <= maxTempSlots) {
  save(lo, len1);
  for (int i = mid, j = lo; i < hi; ++i, ++j) {
   copy(i, j);
  }
  for (int i = 0, j = lo + len2; j < hi; ++i, ++j) {
   restore(i, j);
  }
 } else {
  reverse(lo, mid);
  reverse(mid, hi);
  reverse(lo, hi);
 }
}

@Override
void doRotate(int lo, int mid, int hi) {
 final int len1 = mid - lo;
 final int len2 = hi - mid;
 if (len1 == len2) {
  while (mid < hi) {
   swap(lo++, mid++);
  }
 } else if (len2 < len1 && len2 <= maxTempSlots) {
  save(mid, len2);
  for (int i = lo + len1 - 1, j = hi - 1; i >= lo; --i, --j) {
   copy(i, j);
  }
  for (int i = 0, j = lo; i < len2; ++i, ++j) {
   restore(i, j);
  }
 } else if (len1 <= maxTempSlots) {
  save(lo, len1);
  for (int i = mid, j = lo; i < hi; ++i, ++j) {
   copy(i, j);
  }
  for (int i = 0, j = lo + len2; j < hi; ++i, ++j) {
   restore(i, j);
  }
 } else {
  reverse(lo, mid);
  reverse(mid, hi);
  reverse(lo, hi);
 }
}

/** Compute the length of the next run, make the run sorted and return its
 *  length. */
int nextRun() {
 final int runBase = runEnd(0);
 assert runBase < to;
 if (runBase == to - 1) {
  return 1;
 }
 int o = runBase + 2;
 if (compare(runBase, runBase+1) > 0) {
  // run must be strictly descending
  while (o < to && compare(o - 1, o) > 0) {
   ++o;
  }
  reverse(runBase, o);
 } else {
  // run must be non-descending
  while (o < to && compare(o - 1, o) <= 0) {
   ++o;
  }
 }
 final int runHi = Math.max(o, Math.min(to, runBase + minRun));
 binarySort(runBase, runHi, o);
 return runHi - runBase;
}

/** Compute the length of the next run, make the run sorted and return its
 *  length. */
int nextRun() {
 final int runBase = runEnd(0);
 assert runBase < to;
 if (runBase == to - 1) {
  return 1;
 }
 int o = runBase + 2;
 if (compare(runBase, runBase+1) > 0) {
  // run must be strictly descending
  while (o < to && compare(o - 1, o) > 0) {
   ++o;
  }
  reverse(runBase, o);
 } else {
  // run must be non-descending
  while (o < to && compare(o - 1, o) <= 0) {
   ++o;
  }
 }
 final int runHi = Math.max(o, Math.min(to, runBase + minRun));
 binarySort(runBase, runHi, o);
 return runHi - runBase;
}

/** Compute the length of the next run, make the run sorted and return its
 *  length. */
int nextRun() {
 final int runBase = runEnd(0);
 assert runBase < to;
 if (runBase == to - 1) {
  return 1;
 }
 int o = runBase + 2;
 if (compare(runBase, runBase+1) > 0) {
  // run must be strictly descending
  while (o < to && compare(o - 1, o) > 0) {
   ++o;
  }
  reverse(runBase, o);
 } else {
  // run must be non-descending
  while (o < to && compare(o - 1, o) <= 0) {
   ++o;
  }
 }
 final int runHi = Math.max(o, Math.min(to, runBase + minRun));
 binarySort(runBase, runHi, o);
 return runHi - runBase;
}