* are broken arbitrarily.
   *
   * <p>For example:
   *
   * {@snippet :
   * Stream.of("foo", "quux", "banana", "elephant")
   *     .collect(least(2, comparingInt(String::length)))
   * // returns {"foo", "quux"}
   * }
   *
   * <p>This {@code Collector} uses O(k) memory and takes expected time O(n) (worst-case O(n log

        } else {
            plan.steps(project)
                    .filter(step ->
                            step.phase != null && step.executions().findAny().isPresent())
                    .sorted(Comparator.comparingInt(plan.sortedNodes()::indexOf))
                    .forEach(step -> {
                        writer.accept("\t-----------------------------------------------------------------------");

        }
    }

    private List<MavenProject> getSortedProjects(Set<String> projectIds) {
        return projectIds.stream()
                .map(projects::get)
                .sorted(Comparator.comparingInt(order::get))
                .collect(Collectors.toList());
    }

    @Override
    public String toString() {
        return sorter.getSortedProjects().toString();
    }

            System.arraycopy(existingExtractors, 0, newExtractors, 0, existingExtractors.length);
            newExtractors[newExtractors.length - 1] = extractor;

            Arrays.sort(newExtractors, Comparator.comparingInt(Extractor::getWeight).reversed());

            extractorMap.put(key, newExtractors);
        } else {
            extractorMap.put(key, new Extractor[] { extractor });
        }

        List<ChannelInfo> channelsToRemove = channels.values()
                .stream()
                .filter(c -> !c.isPrimary()) // Never remove primary channel
                .sorted(Comparator.comparingInt(ChannelInfo::getScore)) // Remove lowest scoring first
                .limit(excessCount)
                .collect(ArrayList::new, (list, item) -> list.add(item), (list1, list2) -> list1.addAll(list2));

        
        if (isLargeTransfer(message)) {
            // For large transfers, prefer high-bandwidth channels
            return channels.stream()
                .max(Comparator.comparingInt(c -> c.getRemoteInterface().getLinkSpeed()))
                .orElseThrow();
        }
        
        if (isMetadataOperation(message)) {
            // For metadata operations, prefer low-latency channels