@Override
        public List<ResolvedVariantResult> transform(Collection<ResolvedArtifactResult> artifacts) {
            return artifacts.stream().map(ResolvedArtifactResult::getVariant).collect(Collectors.toList());
        }
    }

    static class FileExtractor implements Transformer<List<RegularFile>, Collection<ResolvedArtifactResult>> {
        private final ProjectLayout projectLayout;

        for (ResolvedGraphDependency d : dependencies) {
            DependencyResult dependencyResult;
            ResolvedVariantResult fromVariant = fromComponent.getVariant(d.getFromVariant());
            if (fromVariant == null) {

    public String getProjectPath() {
        return projectPath;
    }

    @Override
    public String getLibraryName() {
        return libraryName;
    }

    @Override
    public String getVariant() {
        return variant;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {

    }

    public static String getBuildScopedTerseName(LibraryBinaryIdentifier id) {
        return getProjectPrefix(id.getProjectPath()) + id.getLibraryName() + Project.PATH_SEPARATOR + id.getVariant();
    }

    private static String getProjectPrefix(String projectPath) {
        if (Project.PATH_SEPARATOR.equals(projectPath)) {
            return "";
        }

            }

            List<String> getAllToInstall() {
                return allToLink + [install]
            }
        }

        protected String getVariant() {
            String result = ""
            if (operatingSystemFamily != null) {
                result += operatingSystemFamily.toLowerCase().capitalize()
            }
            if (architecture != null) {

    @Override
    public List<? extends ModuleDependencyMetadata> getDependencies() {
        if (calculatedDependencies == null) {
            calculatedDependencies = variantMetadataRules.applyDependencyMetadataRules(getVariant(), super.getDependencies());
        }
        return calculatedDependencies;
    }

    /**
     * This class wraps the component variant so that attribute rules are executed once

    }

    @Nullable
    public ResolvedVariantResult getVariant(Long id) {
        return selectedVariantsById.get(id);
    }

    public void associateDependencyToVariant(DependencyResult dependencyResult, ResolvedVariantResult fromVariant) {

                Map<ComponentIdentifier, ModuleMap> moduleMaps = new LinkedHashMap<>();
                for (ResolvedArtifactResult artifact : importPathConfig.getIncoming().getArtifacts()) {
                    Usage usage = artifact.getVariant().getAttributes().getAttribute(Usage.USAGE_ATTRIBUTE);
                    if (usage != null && Usage.C_PLUS_PLUS_API.equals(usage.getName())) {
                        String moduleName;

                encoder.writeString(libraryIdentifier.getProjectPath());
                encoder.writeString(libraryIdentifier.getLibraryName());
                encoder.writeString(libraryIdentifier.getVariant());
                break;
            case OPAQUE: {
                OpaqueComponentArtifactIdentifier opaqueIdentifier = (OpaqueComponentArtifactIdentifier) value;

            if (componentIdentifier.equals(currentProjectId)) {
                return;
            }
            LibraryElements libraryElements = artifact.getVariant().getAttributes().getAttribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE);
            if (libraryElements == null || !libraryElements.getName().equals(LibraryElements.JAR)) {
                return;
            }