public void init()

in query/src/main/java/jetbrains/exodus/query/InMemoryTimSortIterable.java [116:207]
82 lines of code
24 McCabe index (conditional complexity)

            public void init() {
                src = new ArrayList<>();
                for (final Entity entity : getSrc()) {
                    src.add(entity);
                }
                int n = src.size();
                if (n == 0) {
                    return;
                }
                int minRunLength = n;
                int b = 0;
                while (minRunLength >= InMemoryTimSortIterable.MIN_RUN_LENGTH) {
                    b |= minRunLength;
                    minRunLength >>= 1;
                }
                minRunLength += b & 1;
                int maxRuns = 1 + (n + minRunLength - 1) / minRunLength;
                from = new int[maxRuns * 2 - 1];
                len = new int[maxRuns * 2 - 1];
                left = new int[maxRuns * 2 - 1];
                Arrays.fill(left, -1);
                right = new int[maxRuns * 2 - 1];
                ArrayList<Integer> stack = new ArrayList<>();
                runCount = 0;
                boolean growing = true;
                for (int i = 1; i < n; i++) {
                    // on the run
                    if ((getComparator().compare(src.get(i - 1), src.get(i)) <= 0) == growing) {
                        continue;
                    }
                    // start of run
                    if (i == from[runCount] + 1) {
                        growing = !(growing);
                        continue;
                    }
                    // reverse if needed
                    if (!(growing)) {
                        reverse(i);
                    }
                    // insert several next elements into run to achieve run length minRunLength
                    for (; i < n && i - from[runCount] < minRunLength; i++) {
                        Entity t = src.get(i);
                        int j = i - 1;
                        for (; j >= from[runCount] && getComparator().compare(src.get(j), t) > 0; j--) {
                            src.set(j + 1, src.get(j));
                        }
                        src.set(j + 1, t);
                    }
                    len[runCount] = i - from[runCount];
                    from[++runCount] = i;

                    stack.add(runCount - 1);
                    // collapse
                    while (true) {
                        int s = stack.size();
                        if (s >= 3 && len[stack.get(s - 3)] <= len[stack.get(s - 2)] + len[stack.get(s - 1)]) {
                            if (len[stack.get(s - 3)] < len[stack.get(s - 1)]) {
                                unite(stack, s - 3, maxRuns);
                            } else {
                                unite(stack, s - 2, maxRuns);
                            }
                        } else if (s >= 2 && len[stack.get(s - 2)] <= len[stack.get(s - 1)]) {
                            unite(stack, s - 2, maxRuns);
                        } else {
                            break;
                        }
                    }
                }
                // last run
                len[runCount] = n - from[runCount];
                if (len[runCount] > 0) {
                    // reverse if needed
                    if (!(growing)) {
                        reverse(n);
                    }
                    stack.add(runCount);
                    runCount++;
                }
                // collapse remaining
                for (int i = stack.size() - 2; i >= 0; i--) {
                    if (i > 0 && len[stack.get(i - 1)] < len[stack.get(i + 1)]) {
                        unite(stack, i - 1, maxRuns);
                    } else {
                        unite(stack, i, maxRuns);
                    }
                }
                // for inner nodes min value is unset
                for (int i = 0; i < nodeCount; i++) {
                    from[i + maxRuns] = -1;
                }
                head = stack.get(0);
            }