* </ul>
     * @return the set of results for all requested components
     */
    Set<ComponentResult> getComponents();

    /**
     * <p>Return a set of {@link ComponentResult} instances representing all successfully resolved components.
     *
     * <p>Calling this method is the same as calling {@link #getComponents()} and filtering the resulting set for elements of type {@link ComponentArtifactsResult}.
     *

        final DirectoryProperty buildDirectory = project.getLayout().getBuildDirectory();

        // Create the tasks for each C++ binary that is registered
        project.getComponents().withType(DefaultCppBinary.class, binary -> {
            final Names names = binary.getNames();
            String language = "cpp";

        DefaultCppComponentModel mainComponent = null;
        CppApplication application = project.getComponents().withType(CppApplication.class).findByName("main");
        if (application != null) {

    private final List<String> components;

    public BundleModel(List<String> components, @Nullable String context) {
        super(context);
        this.components = components;
    }

    public List<String> getComponents() {
        return components;
    }

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

    public DefaultArtifactResolutionResult(Set<ComponentResult> componentResults) {
        this.componentResults = componentResults;
    }

    @Override
    public Set<ComponentResult> getComponents() {
        return componentResults;
    }

    @Override
    public Set<ComponentArtifactsResult> getResolvedComponents() {
        Set<ComponentArtifactsResult> resolvedComponentResults = new LinkedHashSet<>();

        project.getDependencies().getAttributesSchema().attribute(Usage.USAGE_ATTRIBUTE).getCompatibilityRules().add(SwiftCppUsageCompatibilityRule.class);

        project.getComponents().withType(DefaultSwiftBinary.class, binary -> {
            final Names names = binary.getNames();
            TaskProvider<SwiftCompile> compile = tasks.register(names.getCompileTaskName("swift"), SwiftCompile.class, task -> {

    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    @Override
    public Set<ExcludeSpec> getComponents() {
        return components;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public String toString() {

        String bundle = getParameters().getBundleName().get();
        DefaultVersionCatalog config = getParameters().getConfig().get();
        BundleModel bundleModel = config.getBundle(bundle);
        return bundleModel.getComponents().stream()
            .map(config::getDependencyData)
            .collect(Collectors.toList());

    }

    Property<RulesMode> getRulesMode();

    /**
     * Returns the shared component metadata handler
     */
    ComponentMetadataHandler getComponents();

    /**
     * Configures the version catalogs which will be used to generate type safe accessors for dependencies.
     * @param spec the spec to configure the dependencies
     *
     * @since 7.0
     */

     *
     * @throws GradleException If the {@code java} component does not exist.
     */
    public static JvmSoftwareComponentInternal getJavaComponent(Project project) {
        SoftwareComponent component = project.getComponents().findByName(JvmConstants.JAVA_MAIN_COMPONENT_NAME);

        if (!(component instanceof JvmSoftwareComponentInternal)) {
            throw new GradleException("The Java plugin must be applied to access the java component.");