this.versionParser = versionParser;
        this.results = Lists.newArrayListWithCapacity(size);
        this.versionComparator = versionComparator;
    }

    public <T extends ComponentResolutionState> List<T> getResolved(ComponentStateFactory<T> componentFactory) {
        ModuleVersionResolveException failure = null;
        List<T> resolved = null;
        boolean hasSoftForce = hasSoftForce();

        int size = results.size();

            preferResults = maybeResolvePreferConstraint(preferResults, selector, allRejects);
        }

        integratePreferResults(selectors, results, preferResults);
        return results.getResolved(componentFactory);
    }

    /**
     * Resolve the 'require' constraint of the selector.
     * A version will be registered for this selector, and it will participate in conflict resolution.
     */

        }

        Artifact artifact = new AttachedArtifact(project.getArtifact(), artifactType, artifactClassifier, handler);

        artifact.setFile(artifactFile);
        artifact.setResolved(true);

        attachArtifact(project, artifact);
    }

    public void attachArtifact(MavenProject project, String artifactType, File artifactFile) {

    }

    /** {@inheritDoc} */
    public int compareTo(Artifact a) {
        return artifact.compareTo(a);
    }

    /** {@inheritDoc} */
    public void setResolved(boolean resolved) {
        artifact.setResolved(resolved);
    }

    /** {@inheritDoc} */
    public boolean isResolved() {
        return artifact.isResolved();
    }

    /** {@inheritDoc} */

        this.resolverProvider = resolverProvider;
        this.repository = repository;
    }

    public JavaToolchainResolver getResolver() {
        return resolverProvider.get();
    }

    public Collection<Authentication> getAuthentications(URI uri) {
        Collection<Authentication> configuredAuthentication = repository.getConfiguredAuthentication();

public interface ModuleConflictHandler extends ConflictHandler<CandidateModule, ConflictResolutionResult> {
    ModuleConflictResolver<ComponentState> getResolver();

                null,
                "pom",
                null,
                new PomArtifactHandler());
        this.project = project;
        setFile(project.getFile());
        setResolved(true);
    }

    public MavenProject getProject() {
        return project;
    }

    public List<Dependency> getDependencies() {
        return project.getModel().getDependencies();
    }

            this.modelResolver = new ModelResolverWrapper() {
                @Override
                protected org.apache.maven.model.resolution.ModelResolver getResolver(
                        List<RemoteRepository> repositories) {
                    return new ProjectModelResolver(
                            session,
                            RequestTrace.newChild(null, request),

                null,
                "maven-plugin",
                null,
                new PluginArtifactHandler());
        this.plugin = plugin;
        setFile(pluginArtifact.getFile());
        setResolved(true);
    }

    public List<Dependency> getDependencies() {
        return plugin.getDependencies();
    }

    public List<Dependency> getManagedDependencies() {
        return Collections.emptyList();

    public MetadataTreeNode(ArtifactMetadata md, MetadataTreeNode parent, boolean resolved, ArtifactScopeEnum scope) {
        if (md != null) {
            md.setArtifactScope(ArtifactScopeEnum.checkScope(scope));
            md.setResolved(resolved);
        }

        this.md = md;
        this.parent = parent;
    }
    // ------------------------------------------------------------------------