import java.util.AbstractMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static gradlebuild.binarycompatibility.upgrades.UpgradedProperties.CURRENT_ACCESSORS_OF_UPGRADED_PROPERTIES;

  /**
   * A collector that converts a stream of zero or one elements to an {@code Optional}.
   *
   * @throws IllegalArgumentException if the stream consists of two or more elements.
   * @throws NullPointerException if any element in the stream is {@code null}.
   * @return {@code Optional.of(onlyElement)} if the stream has exactly one element (must not be

        }
    }

    /**
     * Retrieve a stream of the project's artifacts.
     * Do not include the POM artifact as the file can't be set anyway.
     */
    private Stream<org.apache.maven.artifact.Artifact> getProjectArtifacts(MavenProject project) {
        return Stream.concat(Stream.of(project.getArtifact()), project.getAttachedArtifacts().stream());
    }

                toAdd.stream().map(session::createRemoteRepository).toList();
        if (replace) {
            Set<String> ids = repos.stream().map(RemoteRepository::getId).collect(Collectors.toSet());
            repositories =
                    repositories.stream().filter(r -> !ids.contains(r.getId())).toList();
            pomRepositories = pomRepositories.stream()

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import com.google.inject.Key;
import com.google.inject.OutOfScopeException;
import com.google.inject.Provider;
import com.google.inject.Scope;

/**
 * SessionScope
 */

    public DefaultTypeRegistry(
            List<TypeProvider> providers, LanguageRegistry languageRegistry, LegacyArtifactHandlerManager manager) {
        this.types = nonNull(providers, "providers").stream()
                .flatMap(p -> p.provides().stream())
                .collect(Collectors.toMap(Type::id, identity()));
        this.languageRegistry = nonNull(languageRegistry, "languageRegistry");
        this.usedTypes = new ConcurrentHashMap<>();

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import com.google.inject.AbstractModule;
import com.google.inject.binder.AnnotatedBindingBuilder;
import com.google.inject.name.Names;
import org.apache.maven.api.services.MavenException;

 * under the License.
 */
package org.apache.maven.internal.impl.resolver;

import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.stream.Collectors;

import org.apache.maven.api.ArtifactCoordinate;
import org.apache.maven.api.Session;
import org.apache.maven.api.Version;
import org.apache.maven.api.di.Named;
import org.apache.maven.api.di.Singleton;

                internalSession.toRepositories(nonNull(dominant, "dominant")),
                internalSession.toRepositories(nonNull(recessive, "recessive")),
                processRecessive);
        return repos.stream()
                .<RemoteRepository>map(DefaultRemoteRepository::new)
                .toList();
    }

    public static org.eclipse.aether.repository.RepositoryPolicy buildRepositoryPolicy(

    private final List<Object> objects;

    public SimpleLookup(List<Object> objects) {
        this.objects = objects;
    }

    @Override
    public <T> T lookup(Class<T> type) {
        return objects.stream()
                .filter(type::isInstance)
                .map(type::cast)
                .findAny()
                .orElseThrow(() -> new LookupException("No service of type " + type));
    }

    @Override