@Override
      protected Multiset<String> create(String[] elements) {
        return LinkedHashMultiset.create(asList(elements));
      }

      @Override
      public List<String> order(List<String> insertionOrder) {
        List<String> order = new ArrayList<>();
        for (String s : insertionOrder) {
          int index = order.indexOf(s);
          if (index == -1) {
            order.add(s);
          } else {

{
  "annotations": {
    "list": [
      {
        "builtIn": 1,
        "datasource": {
          "type": "datasource",
          "uid": "grafana"
        },
        "enable": true,
        "hide": true,
        "iconColor": "rgba(0, 211, 255, 1)",
        "name": "Annotations & Alerts",
        "type": "dashboard"
      }
    ]
  },
  "description": "MinIO Grafana Dashboard - https://min.io/",
  "editable": true,

        private final String name;
        private final List<Plugin> plugins;
        private final Collection<Lifecycle.Link> links;
        private final List<Lifecycle.Phase> phases;

        DefaultPhase(
                String name, List<Plugin> plugins, Collection<Lifecycle.Link> links, List<Lifecycle.Phase> phases) {
            this.name = name;
            this.plugins = plugins;

    ResolutionGroup retrieve(
            Artifact artifact, ArtifactRepository localRepository, List<ArtifactRepository> remoteRepositories)
            throws ArtifactMetadataRetrievalException;

    List<ArtifactVersion> retrieveAvailableVersions(MetadataResolutionRequest request)
            throws ArtifactMetadataRetrievalException;

    @Override
    List<ArtifactVersion> retrieveAvailableVersions(

        updateProjectSourceRoot();
    }

    @Override
    public void setIncludes(List<String> includes) {
        // Update the underlying Resource model
        super.setIncludes(includes);

        // Update the project's SourceRoots
        updateProjectSourceRoot();
    }

    @Override
    public void setExcludes(List<String> excludes) {
        // Update the underlying Resource model

     * @param host the hostname or IP address string
     * @param port the port number
     * @param path the path (should start with "/" or be empty)
     * @return the complete URL string
     */
    public static String buildUrl(final String protocol, final String host, final int port, final String path) {
        if (protocol == null || host == null) {
            return null;
        }

    double[] array = {0.0, 1.0};
    List<Double> list = Doubles.asList(array);
    list.set(0, 2.0);
    assertThat(array).isEqualTo(new double[] {2.0, 1.0});
    array[1] = 3.0;
    assertThat(list).containsExactly(2.0, 3.0).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    double[] array = {0.0, 1.0, 2.0};
    List<Double> list = Doubles.asList(array);

import java.nio.file.PathMatcher;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.model.Exclusion;

/**
 * Filter to exclude from a list of artifact patterns.
 */
public class ExclusionArtifactFilter implements ArtifactFilter {

    private final List<Exclusion> exclusions;

     *
     * @since 3.5.0
     */
    List<MavenProject> getAllProjects();

    /**
     * Gets all projects in their intended build order, i.e. after topologically sorting the projects according to their
     * interdependencies.
     *
     * @return The projects in the build order, never {@code null}.
     */
    List<MavenProject> getSortedProjects();

    /**

    private final RepositorySystemSession session;

    private final RequestTrace trace;

    private final String context = "project";

    private List<RemoteRepository> repositories;

    private List<RemoteRepository> pomRepositories;

    private final List<RemoteRepository> externalRepositories;

    private final RepositorySystem resolver;

    private final RemoteRepositoryManager remoteRepositoryManager;