return Collections.unmodifiableMap(node.stream()
                        .filter(Objects::nonNull)
                        .map(Node::getDependency)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toMap(d -> d.getGroupId() + ":" + d.getArtifactId(), d -> d)));
            }
        };
    }

    @Override

        this.artifactTransformations = Stream.of("release", "latest", "snapshot")
                .map(artifactTransformations::get)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    public void transformForResolve(Artifact artifact, RepositoryRequest request)
            throws ArtifactResolutionException, ArtifactNotFoundException {

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collection;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Static utility methods pertaining to object arrays.
 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@GwtCompatible(emulated = true)

  @CollectionSize.Require(absent = ZERO)
  public void testSpliteratorNullable() {
    initCollectionWithNullElement();
    assertFalse(collection.spliterator().hasCharacteristics(Spliterator.NONNULL));
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testSpliteratorNotImmutable_collectionAllowsAdd() {
    // If add is supported, verify that IMMUTABLE is not reported.

                .map(m -> m.locate(projectDirectory)
                        .map(org.apache.maven.api.services.Source::getPath)
                        .orElse(null))
                .filter(Objects::nonNull)
                .findFirst()
                .orElseGet(() -> modelLocator.locatePom(projectDirectory));
        if (!pom.equals(projectDirectory) && !pom.getParent().equals(projectDirectory)) {

   * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (Even if supported added {@code @NonNull}, that would not help, since the problem case
   * addressed by this method is the case in which {@code T} has parametric nullness -- and thus its
   * value may be legitimately {@code null}.)
   */
  @ParametricNullness

     * and Equivalence<Object>.
     */
    private final Equivalence<? super @NonNull T> equivalence;

    @ParametricNullness private final T reference;

    private Wrapper(Equivalence<? super @NonNull T> equivalence, @ParametricNullness T reference) {
      this.equivalence = checkNotNull(equivalence);
      this.reference = reference;
    }

  @CollectionSize.Require(absent = ZERO)
  public void testSpliteratorNullable() {
    initCollectionWithNullElement();
    assertFalse(collection.spliterator().hasCharacteristics(Spliterator.NONNULL));
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testSpliteratorNotImmutable_collectionAllowsAdd() {
    // If add is supported, verify that IMMUTABLE is not reported.

   * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (Even if supported added {@code @NonNull}, that would not help, since the problem case
   * addressed by this method is the case in which {@code T} has parametric nullness -- and thus its
   * value may be legitimately {@code null}.)
   */

   * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (Even if supported added {@code @NonNull}, that would not help, since the problem case
   * addressed by this method is the case in which {@code T} has parametric nullness -- and thus its
   * value may be legitimately {@code null}.)
   */
  @ParametricNullness