buf.append(roleTypeList.stream().sorted().collect(Collectors.joining(",")));
        }

        @SuppressWarnings("unchecked")
        final List<String> virtualHostList = (List<String>) dataMap.get(fessConfig.getIndexFieldVirtualHost());
        if (virtualHostList != null && !virtualHostList.isEmpty()) {
            buf.append(";v=");
            buf.append(virtualHostList.stream().sorted().collect(Collectors.joining(",")));
        }

   * // returns {"foo", "quux"}
   * }
   *
   * <p>This {@code Collector} uses O(k) memory and takes expected time O(n) (worst-case O(n log
   * k)), as opposed to e.g. {@code Stream.sorted(comparator).limit(k)}, which currently takes O(n
   * log n) time and O(n) space.
   *
   * @throws IllegalArgumentException if {@code k < 0}
   * @since 22.0
   */

                            }
                        }
                    }
                }
                add(minimumSupported)
            }.filterNotNull().distinct().sorted()
            return latests.subList(latests.indexOf(minimumSupported), latests.size)
        }
    }

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

            val allMinorLatests = allVersions.map { version ->
                VersionNumber.parse(version)
            }.sorted().groupBy { version ->
                VersionNumber.version(version.major, version.minor)
            }.map { (_, versions) ->
                versions.last()
            }

import com.google.common.annotations.GwtCompatible;
import java.util.List;
import java.util.SortedSet;
import org.jspecify.annotations.NullMarked;

/**
 * Create string sets for testing collections that are sorted by natural ordering.
 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public abstract class TestStringSortedSetGenerator extends TestStringSetGenerator
    implements TestSortedSetGenerator<String> {

import java.util.Collection;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import org.jspecify.annotations.Nullable;

/**
 * Basic implementation of a {@link SortedSetMultimap} with a sorted key set.
 *
 * <p>This superclass allows {@code TreeMultimap} to override methods to return navigable set and
 * map types in non-GWT only, while GWT code will inherit the SortedMap/SortedSet overrides.
 *

package com.google.common.collect;

import java.util.Comparator;
import java.util.Iterator;
import java.util.SortedSet;
import org.jspecify.annotations.Nullable;

/**
 * A sorted multiset which forwards all its method calls to another sorted multiset. Subclasses
 * should override one or more methods to modify the behavior of the backing multiset as desired per

import java.util.List;
import java.util.Map.Entry;
import java.util.SortedMap;
import org.jspecify.annotations.NullMarked;

/**
 * Implementation helper for {@link TestMapGenerator} for use with sorted maps of strings.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked
public abstract class TestStringSortedMapGenerator extends TestStringMapGenerator
    implements TestSortedMapGenerator<String, String> {

import java.util.List;
import java.util.Map.Entry;
import java.util.SortedMap;
import org.jspecify.annotations.NullMarked;

/**
 * Implementation helper for {@link TestMapGenerator} for use with sorted maps of strings.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked
public abstract class TestStringSortedMapGenerator extends TestStringMapGenerator
    implements TestSortedMapGenerator<String, String> {