import org.gradle.platform.base.internal.dependents.DependentBinariesResolver;
import org.gradle.work.DisableCachingByDefault;

import javax.inject.Inject;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import static org.gradle.api.reporting.dependents.internal.DependentComponentsUtils.getAllComponents;
import static org.gradle.api.reporting.dependents.internal.DependentComponentsUtils.getAllTestSuites;

import org.gradle.platform.base.internal.BinarySpecInternal;
import org.gradle.platform.base.internal.ComponentSpecInternal;
import org.gradle.platform.base.internal.dependents.DependentBinariesResolutionResult;
import org.gradle.platform.base.internal.dependents.DependentBinariesResolver;
import org.gradle.reporting.ReportRenderer;

import javax.annotation.Nullable;
import java.util.LinkedHashSet;

  - name: "registry.k8s.io/distroless-iptables: dependents"
    version: v0.5.5
    refPaths:
    - path: build/common.sh
      match: __default_distroless_iptables_version=
    - path: test/utils/image/manifest.go
      match: configs\[DistrolessIptables\] = Config{list\.BuildImageRegistry, "distroless-iptables", "v([0-9]+)\.([0-9]+)\.([0-9]+)"}

  - name: "registry.k8s.io/go-runner: dependents"
    version: v2.3.1-go1.22.4-bookworm.0

        return Collections.unmodifiableSet(dependents);
    }

    public DefaultResolvedComponentResult addDependency(DependencyResult dependency) {
        this.dependencies.add(dependency);
        return this;
    }

    public DefaultResolvedComponentResult addDependent(ResolvedDependencyResult dependent) {
        this.dependents.add(dependent);
        return this;
    }

    @Override

        DependentsSet dependents = current.findDependentsOfClasspathChanges(previous);
        if (dependents.isDependencyToAll()) {
            spec.setFullRebuildCause(dependents.getDescription());
            return;
        }
        spec.addClassesToCompile(dependents.getPrivateDependentClasses());
        spec.addClassesToCompile(dependents.getAccessibleDependentClasses());

    def hash = TestHashCodes.hashCodeFrom(0)
    def accumulator = new ClassDependentsAccumulator()

    def "dependents map is empty by default"() {
        expect:
        accumulator.dependentsMap == [:]
    }

    def "remembers if class is dependency to all"() {
        // a -> b -> c
        accumulator.addClass("a", hash, null, [], ["b"], IntSets.EMPTY_SET)

            if (dependencies == null) {
                dependencies = new HashSet<>();
            }
            dependencies.add(node);
            if (node.dependents == null) {
                node.dependents = new HashSet<>();
            }
            node.dependents.add(this);
        }
        if (executedRules == null) {
            executedRules = new ArrayList<>();
        }

class NativeDependentComponentsReportIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        settingsFile << "rootProject.name = 'test'"
    }

    def "displays dependents report for all components of the task's project"() {
        given:
        buildScript simpleCppBuild()

        when:
        run "dependentComponents"

        then:

        run "app:${language.compileTaskName}", "-x", "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
        app.recompiledClasses("C")
    }

    def "deletion of jar without dependents does not recompile any classes"() {
        source api: ["class A {}"], impl: ["class SomeImpl {}"]
        impl.snapshot { run language.compileTaskName }

        when:
        clearImplProjectDependencies()

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.platform.base.internal.dependents;

import org.gradle.api.Named;
import org.gradle.platform.base.internal.BinarySpecInternal;

/**
 * Strategy to resolve dependent binaries.
 */
public interface DependentBinariesResolutionStrategy extends Named {