*/
    public List<ModelProblem> getProblems() {
        if (result == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(result.getProblems());
    }

  fun queuedCalls(): List<Call> =
    this.withLock {
      return Collections.unmodifiableList(readyAsyncCalls.map { it.call })
    }

  /** Returns a snapshot of the calls currently being executed. */
  fun runningCalls(): List<Call> =
    this.withLock {
      return Collections.unmodifiableList(runningSyncCalls + runningAsyncCalls.map { it.call })
    }

    }

    public List<Dependency> getManagedDependencies() {
        DependencyManagement depMngt = project.getModel().getDependencyManagement();
        return (depMngt != null) ? Collections.unmodifiableList(depMngt.getDependencies()) : Collections.emptyList();
    }

    // TODO: this is duplicate of PomArtifactHandlerProvider provided one
    static class PomArtifactHandler implements ArtifactHandler {
        @Override

 */
public class ProjectBuildList implements Iterable<ProjectSegment> {
    private final List<ProjectSegment> items;

    public ProjectBuildList(List<ProjectSegment> items) {
        this.items = Collections.unmodifiableList(items);
    }

    // TODO Optimize; or maybe just rewrite the whole way aggregating mojos are being run.
    /**
     * Returns aProjectBuildList that contains only items for the specified taskSegment

   * an ImmutableList)
   */
  public synchronized List<LogRecord> getStoredLogRecords() {
    List<LogRecord> result = new ArrayList<>(list);
    return Collections.unmodifiableList(result);
  }

   * an ImmutableList)
   */
  public synchronized List<LogRecord> getStoredLogRecords() {
    List<LogRecord> result = new ArrayList<>(list);
    return Collections.unmodifiableList(result);
  }

        return this;
    }

    public List<MavenProject> getTopologicallySortedProjects() {
        return null == topologicallySortedProjects
                ? Collections.emptyList()
                : Collections.unmodifiableList(topologicallySortedProjects);
    }

    public DependencyResolutionResult getDependencyResolutionResult() {
        return dependencyResolutionResult;
    }

                defaultBindings.put(pluginBindings[i], new LifecyclePhase(pluginBindings[i + 1]));
            }
        }

        this.lifecycle = new Lifecycle(
                id,
                Collections.unmodifiableList(Arrays.asList(phases)),
                defaultBindings == null ? null : Collections.unmodifiableMap(defaultBindings));
    }

    @Override
    public Lifecycle get() {
        return lifecycle;
    }

        List<Node> children =
                getChildren().stream().filter(filter).map(n -> n.filter(filter)).collect(Collectors.toList());
        return new WrapperNode(this, Collections.unmodifiableList(children));
    }

    @Override
    public String asString() {
        StringBuilder sb = new StringBuilder();

        DependencyNode node = getDependencyNode();

        }
    }

    public List<Exception> getResolutionErrors(Dependency dependency) {
        List<Exception> errors = resolutionErrors.get(dependency);
        return (errors != null) ? Collections.unmodifiableList(errors) : Collections.emptyList();
    }

    public void setResolutionErrors(Dependency dependency, List<Exception> errors) {
        dependencies.add(dependency);
        unresolvedDependencies.add(dependency);