public void qsort()

in query/src/main/java/jetbrains/exodus/query/InMemoryQuickSortTwoSidesIterable.java [74:135]
60 lines of code
17 McCabe index (conditional complexity)

            public void qsort(int left, int right) {
                if (left >= right) {
                    return;
                }
                Entity median = src.get((left + right) / 2);
                int i = left;
                int j = right;
                int toRight = 0;
                int toLeft = 0;
                List<Entity> leftMedians = new ArrayList<>();
                List<Entity> rightMedians = new ArrayList<>();
                final Comparator<Entity> comparator = getComparator();
                do {
                    while (i <= j && comparator.compare(src.get(i), median) < 0) {
                        if (toRight + leftMedians.size() > 0) {
                            src.set(i - toRight - leftMedians.size(), src.get(i));
                        }
                        i++;
                    }
                    while (i <= j && comparator.compare(median, src.get(j)) < 0) {
                        if (toLeft + rightMedians.size() > 0) {
                            src.set(j + toLeft + rightMedians.size(), src.get(j));
                        }
                        j--;
                    }
                    // src[i] >= median and src[j] <= median
                    if (i <= j) {
                        Entity leftEntity = src.get(i);
                        if (comparator.compare(leftEntity, median) == 0) {
                            leftMedians.add(leftEntity);
                        } else {
                            tmp[toRight++] = leftEntity;
                        }
                        i++;
                    }
                    if (i <= j) {
                        Entity rightEntity = src.get(j);
                        if (comparator.compare(rightEntity, median) == 0) {
                            rightMedians.add(rightEntity);
                        } else {
                            tmp[right - toLeft++] = src.get(j);
                        }
                        j--;
                    }
                } while (i <= j);
                // i == j + 1
                int current = i - toRight - leftMedians.size();
                for (int k = right - toLeft + 1; k <= right; k++) {
                    src.set(current++, tmp[k]);
                }
                for (Entity e : leftMedians) {
                    src.set(current++, e);
                }
                for (int k = rightMedians.size() - 1; k >= 0; k--) {
                    src.set(current++, rightMedians.get(k));
                }
                for (int k = 0; k < toRight; k++) {
                    src.set(current++, tmp[k]);
                }
                qsort(left, i - toRight - leftMedians.size() + toLeft);
                qsort(current - toRight, right);
            }