import static java.util.Objects.requireNonNull;

public class DefaultTransport implements Transport {
    private final URI baseURI;
    private final Transporter transporter;

    public DefaultTransport(URI baseURI, Transporter transporter) {
        this.baseURI = requireNonNull(baseURI);
        this.transporter = requireNonNull(transporter);
    }

    @Override

                Objects.requireNonNull(remoteRepositoryManager, "remoteRepositoryManager cannot be null");
        this.versionResolver = Objects.requireNonNull(versionResolver, "versionResolver cannot be null");
        this.versionRangeResolver = Objects.requireNonNull(versionRangeResolver, "versionRangeResolver cannot be null");
        this.artifactResolver = Objects.requireNonNull(artifactResolver, "artifactResolver cannot be null");

@ElementTypesAreNonnullByDefault
final class Platform {
  private Platform() {}

  /** Returns a thread-local 1024-char array. */
  static char[] charBufferFromThreadLocal() {
    // requireNonNull accommodates Android's @RecentlyNullable annotation on ThreadLocal.get
    return requireNonNull(DEST_TL.get());
  }

  /**
   * A thread-local destination buffer to keep us from creating new buffers. The starting size is

import org.apache.maven.artifact.handler.DefaultArtifactHandler;
import org.apache.maven.eventspy.AbstractEventSpy;
import org.apache.maven.execution.ExecutionEvent;

import static java.util.Objects.requireNonNull;

/**
 */
@Named
@Singleton
public class LegacyArtifactHandlerManager extends AbstractEventSpy {
    private final Map<String, ArtifactHandler> artifactHandlers;

       *   modification is undefined, anyway.)
       */
      requireNonNull(rowEntry);
      Entry<C, V> columnEntry = columnIterator.next();
      return Tables.immutableCell(rowEntry.getKey(), columnEntry.getKey(), columnEntry.getValue());
    }

    @Override
    public void remove() {
      columnIterator.remove();
      /*
       * requireNonNull is safe because:
       *

            ProjectBuildingRequest projectBuildingRequest) {
        this.project = Objects.requireNonNull(project, "project cannot be null");
        this.projectBuildingHelper =
                Objects.requireNonNull(projectBuildingHelper, "projectBuildingHelper cannot be null");
        this.projectBuildingRequest =
                Objects.requireNonNull(projectBuildingRequest, "projectBuildingRequest cannot be null");

  private static <N, V> Map<EndpointPair<N>, V> edgeValueMap(final ValueGraph<N, V> graph) {
    return Maps.asMap(
        graph.edges(),
        edge ->
            // requireNonNull is safe because the endpoint pair comes from the graph.
            requireNonNull(graph.edgeValueOrDefault(edge.nodeU(), edge.nodeV(), null)));
  }

import org.eclipse.aether.artifact.ArtifactTypeRegistry;

import static java.util.Objects.requireNonNull;

class TypeRegistryAdapter implements ArtifactTypeRegistry {
    private final TypeRegistry typeRegistry;

    TypeRegistryAdapter(TypeRegistry typeRegistry) {
        this.typeRegistry = requireNonNull(typeRegistry, "typeRegistry");
    }

    @Override
    public ArtifactType get(String typeId) {

      RegularImmutableMap<K, V> empty = (RegularImmutableMap<K, V>) EMPTY;
      return empty;
    } else if (n == 1) {
      // requireNonNull is safe because the first `2*n` elements have been filled in.
      checkEntryNotNull(
          requireNonNull(alternatingKeysAndValues[0]), requireNonNull(alternatingKeysAndValues[1]));
      return new RegularImmutableMap<K, V>(null, alternatingKeysAndValues, 1);
    }

        this.versionScheme = requireNonNull(versionScheme, "versionScheme");
    }

    @Override
    public Version parseVersion(String version) {
        requireNonNull(version, "version");
        return new DefaultVersion(versionScheme, version);
    }

    @Override
    public VersionRange parseVersionRange(String range) {
        requireNonNull(range, "range");