import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public ReactorBuildQueue(Collection<MavenProject> projects,
    ProjectDependencyGraph dependencyGraph) {
  this.dependencyGraph = dependencyGraph;

  final Set<MavenProject> rootProjects = new HashSet<MavenProject>();

  for (MavenProject project : projects) {
    if (dependencyGraph.getUpstreamProjects(project, false).isEmpty()) {
      rootProjects.add(project);
    } else {
      blockedProjects.add(project);
    }
  }

  this.rootProjects = ImmutableSet.copyOf(rootProjects);
  this.projects = ImmutableSet.copyOf(projects);
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
/**
 * Creates a new project dependency graph from the specified graph.
 * 
 * @param projectDependencyGraph The project dependency graph to create a sub view from, must not be {@code null}.
 * @param whiteList The projects on which the dependency view should focus, must not be {@code null}.
 */
public FilteredProjectDependencyGraph( ProjectDependencyGraph projectDependencyGraph,
                                       Collection<? extends MavenProject> whiteList )
{
    if ( projectDependencyGraph == null )
    {
        throw new IllegalArgumentException( "project dependency graph missing" );
    }

    this.projectDependencyGraph = projectDependencyGraph;

    this.whiteList = new IdentityHashMap<MavenProject, Object>();

    for ( MavenProject project : whiteList )
    {
        this.whiteList.put( project, null );
    }
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
private ProjectDependencyGraph createDependencyGraph( ProjectSorter sorter, MavenExecutionRequest request )
    throws MavenExecutionException
{
    ProjectDependencyGraph graph = new DefaultProjectDependencyGraph( sorter );

    List<MavenProject> activeProjects = sorter.getSortedProjects();

    activeProjects = trimSelectedProjects( activeProjects, graph, request );
    activeProjects = trimResumedProjects( activeProjects, request );

    if ( activeProjects.size() != sorter.getSortedProjects().size() )
    {
        graph = new FilteredProjectDependencyGraph( graph, activeProjects );
    }

    return graph;
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public void testConcurrencyGraphDifferentCompletionOrder()
    throws InvalidPluginDescriptorException, PluginVersionResolutionException, PluginDescriptorParsingException,
    NoPluginFoundForPrefixException, MojoNotFoundException, PluginNotFoundException, PluginResolutionException,
    LifecyclePhaseNotFoundException, LifecycleNotFoundException
{
    ProjectDependencyGraph dependencyGraph = new ProjectDependencyGraphStub();
    final MavenSession session = ProjectDependencyGraphStub.getMavenSession();
    ConcurrencyDependencyGraph graph =
        new ConcurrencyDependencyGraph( getProjectBuildList( session ), dependencyGraph );

    graph.markAsFinished( A );
    final List<MavenProject> cDescendants = graph.markAsFinished( C );
    assertEquals( 1, cDescendants.size() );
    assertEquals( Z, cDescendants.get( 0 ) );

    final List<MavenProject> bDescendants = graph.markAsFinished( B );
    assertEquals( 2, bDescendants.size() );
    assertEquals( X, bDescendants.get( 0 ) );
    assertEquals( Y, bDescendants.get( 1 ) );
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
IncrementalModuleBuilderImpl( List<MavenProject> selectedProjects, LifecycleModuleBuilder lifecycleModuleBuilder,
                              MavenSession session, ReactorContext reactorContext, List<TaskSegment> taskSegments )
{

    this.lifecycleModuleBuilder =
        Objects.requireNonNull( lifecycleModuleBuilder, "lifecycleModuleBuilder is not allowed to be null." );
    this.mavenSession = Objects.requireNonNull( session, "session is not allowed to be null." );
    this.taskSegments = Objects.requireNonNull( taskSegments, "taskSegements is not allowed to be null" );
    this.reactorContext = Objects.requireNonNull( reactorContext, "reactorContext is not allowed to be null." );

    ProjectDependencyGraph projectDependencyGraph = session.getProjectDependencyGraph();

    List<MavenProject> intermediateResult = new LinkedList<>();

    for ( MavenProject selectedProject : selectedProjects )
    {
        intermediateResult.add( selectedProject );
        // Up or downstream ? (-amd)
        intermediateResult.addAll( projectDependencyGraph.getDownstreamProjects( selectedProject, true ) );
        // TODO: Need to think about this? -am ?
        // intermediateResult.addAll(projectDependencyGraph.getUpstreamProjects(selectedProject,
        // true));
    }

    List<MavenProject> result = new LinkedList<>();

    for ( MavenProject project : intermediateResult )
    {
        if ( !result.contains( project ) )
        {
            result.add( project );
        }
    }

    this.projects = result;

}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public ProjectSegment( MavenProject project, TaskSegment taskSegment, MavenSession copiedSession )
{
    this.project = project;
    this.taskSegment = taskSegment;
    this.session = copiedSession;
    final ProjectDependencyGraph dependencyGraph = getSession().getProjectDependencyGraph();
    nonTransitiveUpstreamProjects = dependencyGraph.getUpstreamProjects( getProject(), false );
    transitiveUpstreamProjects = dependencyGraph.getUpstreamProjects( getProject(), true );
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public void logWeavePlan( MavenSession session )
{
    if ( !logger.isInfoEnabled() )
    {
        return;
    }

    final ProjectDependencyGraph dependencyGraph = session.getProjectDependencyGraph();
    logger.info( "=== WEAVE CONCURRENCY BUILD PLAN ======================================" );
    for ( MavenProject mavenProject : dependencyGraph.getSortedProjects() )
    {

        StringBuilder item = new StringBuilder();
        item.append( "Project: " );
        item.append( mavenProject.getArtifactId() );
        final List<MavenProject> upstreamProjects = dependencyGraph.getUpstreamProjects( mavenProject, false );
        if ( upstreamProjects.size() > 0 )
        {
            item.append( " ( " );
            for ( Iterator<MavenProject> it = upstreamProjects.iterator(); it.hasNext(); )
            {
                final MavenProject kid = it.next();
                item.append( kid.getArtifactId() );
                if ( it.hasNext() )
                {
                    item.append( ", " );
                }
            }
            item.append( ")" );
        }
        logger.info( item.toString() );

    }
    logger.info( "=======================================================================" );
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public void testConcurrencyGraphPrimaryVersion()
    throws InvalidPluginDescriptorException, PluginVersionResolutionException, PluginDescriptorParsingException,
    NoPluginFoundForPrefixException, MojoNotFoundException, PluginNotFoundException, PluginResolutionException,
    LifecyclePhaseNotFoundException, LifecycleNotFoundException
{
    ProjectDependencyGraph dependencyGraph = new ProjectDependencyGraphStub();
    final MavenSession session = ProjectDependencyGraphStub.getMavenSession();

    ConcurrencyDependencyGraph graph =
        new ConcurrencyDependencyGraph( getProjectBuildList( session ), dependencyGraph );

    final List<MavenProject> projectBuilds = graph.getRootSchedulableBuilds();
    assertEquals( 1, projectBuilds.size() );
    assertEquals( A, projectBuilds.get( 0 ) );

    final List<MavenProject> subsequent = graph.markAsFinished( A );
    assertEquals( 2, subsequent.size() );
    assertEquals( ProjectDependencyGraphStub.B, subsequent.get( 0 ) );
    assertEquals( C, subsequent.get( 1 ) );

    final List<MavenProject> bDescendants = graph.markAsFinished( B );
    assertEquals( 1, bDescendants.size() );
    assertEquals( Y, bDescendants.get( 0 ) );

    final List<MavenProject> cDescendants = graph.markAsFinished( C );
    assertEquals( 2, cDescendants.size() );
    assertEquals( X, cDescendants.get( 0 ) );
    assertEquals( Z, cDescendants.get( 1 ) );
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public String renderCriticalPath(ProjectDependencyGraph graph) {
  return renderCriticalPath(DependencyGraph.fromMaven(graph), p -> projectGA(p));
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public static Comparator<MavenProject> create(MavenSession session) {
  final ProjectDependencyGraph dependencyGraph = session.getProjectDependencyGraph();
  return create0(DependencyGraph.fromMaven(dependencyGraph), ImmutableMap.of(), p -> id(p));
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public ConcurrencyDependencyGraph( ProjectBuildList projectBuilds, ProjectDependencyGraph projectDependencyGraph )
{
    this.projectDependencyGraph = projectDependencyGraph;
    this.projectBuilds = projectBuilds;
}
 

import org.apache.maven.execution.ProjectDependencyGraph; //导入依赖的package包/类
public ReactorBuildStatus( ProjectDependencyGraph projectDependencyGraph )
{
    this.projectDependencyGraph = projectDependencyGraph;
}