examined {@link Iterable} */ public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(T... items) { return org.hamcrest.core.IsCollectionContaini.<T>hasItems(items); } /** * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the * examined {@link Iterable} yield at least one item that is matched by the corresponding * matcher from the specified <code>itemMatchers</code>. Whilst matching, each traversal of * the examined {@link Iterable} will stop as soon...

//      from the plugin archive.
// TODO this will be the class that people get in IDEs to modify

/**
 * MavenExecutionPlan
 */
public class MavenExecutionPlan implements Iterable<ExecutionPlanItem> {

    /*
      At the moment, this class is totally immutable, and this is in line with thoughts about the
      pre-calculated execution plan that stays the same during the execution.

method on the examined object. static <U> Matcher<java.lang.Iterable<U>> everyItem(Matcher<U> itemMatcher) Creates a matcher for Iterables that only matches when a single pass over the examined Iterable yields items that are all matched by the specified itemMatcher. static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher) Creates a matcher for Iterables that only matches when a single pass over the examined Iterable yields at least one item that is matched by the specified...

                if (artifactLastModified > buildStartTime) {
                    return true;
                }
            }

            for (Path outputFile : (Iterable<Path>) outputFiles::iterator) {
                if (Files.isDirectory(outputFile)) {
                    continue;
                }

                long outputFileLastModified =

import java.util.List;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import org.apache.maven.api.Lifecycle;

public interface LifecycleRegistry extends ExtensibleEnumRegistry<Lifecycle>, Iterable<Lifecycle> {
    default Stream<Lifecycle> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    List<String> computePhases(Lifecycle lifecycle);

import java.util.List;

import org.apache.maven.artifact.ArtifactScopeEnum;

/**
 * classpath container that is aware of the classpath scope
 *
 *
 */
@Deprecated
public class ClasspathContainer implements Iterable<ArtifactMetadata> {
    private List<ArtifactMetadata> classpath;

    private ArtifactScopeEnum scope;

    // -------------------------------------------------------------------------------------------

            projectIds.add(key);
        }
        return projectIds;
    }

    private Set<String> getIgnorableArtifacts(Iterable<Artifact> artifactIterable) {
        Set<String> projectIds = new HashSet<>();

        for (Artifact artifact : artifactIterable) {
            String key = ArtifactUtils.key(artifact);

     */
    @Nonnull
    @Override
    public String option(Iterable<? extends Path> paths) {
        return format(null, paths);
    }

    /**
     * Implementation shared with {@link Modular}.
     */
    String format(String moduleName, Iterable<? extends Path> paths) {
        if (option == null) {

            repositories = remoteRepositoryManager.aggregateRepositories(
                    session, pomRepositories, externalRepositories, false);
        }
    }

    private static void removeMatchingRepository(Iterable<RemoteRepository> repositories, final String id) {
        Iterator<RemoteRepository> iterator = repositories.iterator();
        while (iterator.hasNext()) {
            RemoteRepository next = iterator.next();

            return "UNRESOLVED";
        }

        @Override
        public Optional<String> option() {
            return Optional.empty();
        }

        @Override
        public String option(Iterable<? extends Path> paths) {
            return "";
        }
    };

    /**
     * Returns the unique name of this path type, including the module to patch if any.