if (alreadySeen.add(component.getFrom())) {
            currentPath.add(0, component);
            for (EdgeState dependent : component.getFrom().getIncomingEdges()) {
                List<EdgeState> otherPath = Lists.newArrayList(currentPath);
                pathTo(dependent, otherPath, accumulator, alreadySeen);
            }
            if (component.getFrom().isRoot()) {
                accumulator.add(currentPath);

        dependencyHandler.registerTransform(
            InstrumentationAnalysisTransform.class,
            spec -> {
                spec.getFrom().attribute(INSTRUMENTED_ATTRIBUTE, NOT_INSTRUMENTED.getValue());
                spec.getTo().attribute(INSTRUMENTED_ATTRIBUTE, ANALYZED_ARTIFACT.getValue());
                spec.parameters(params -> {

        return dependency.getSelected().getId();
    }

    @Override
    public ComponentIdentifier getFrom() {
        return dependency.getFrom().getId();
    }

    @Override
    public Set<? extends RenderableDependency> getChildren() {
        return Collections.singleton(new InvertedRenderableModuleResult(dependency.getFrom()));
    }

        return Collections.emptyList();
    }

    @Override
    public ComponentIdentifier getFrom() {
        return dependency.getFrom().getId();
    }

    @Override
    public Set<? extends RenderableDependency> getChildren() {
        return Collections.singleton(new InvertedRenderableModuleResult(dependency.getFrom()));
    }

func (r *Cache) DependentConfigs() []model.ConfigHash {
	size := len(r.Services) + len(r.VirtualServices) + len(r.DelegateVirtualServices) + len(r.EnvoyFilterKeys)
	for _, mergedDR := range r.DestinationRules {
		size += len(mergedDR.GetFrom())
	}
	configs := make([]model.ConfigHash, 0, size)
	for _, svc := range r.Services {
		configs = append(configs, model.ConfigKey{
			Kind:      kind.ServiceEntry,
			Name:      string(svc.Hostname),

import java.util.List;
import java.util.Set;

public interface DependencyEdge {
    boolean isResolvable();

    ComponentSelector getRequested();

    ComponentIdentifier getActual();

    ComponentIdentifier getFrom();

    ComponentSelectionReason getReason();

    List<ResolvedVariantResult> getSelectedVariants();

    List<ResolvedVariantResult> getAllVariants();

    Set<? extends RenderableDependency> getChildren();

        this.constraint = constraint;
    }

    @Override
    public ComponentSelector getRequested() {
        return requested;
    }

    @Override
    public ResolvedComponentResult getFrom() {
        return from;
    }

    @Override
    public boolean isConstraint() {
        return constraint;
    }

        for (EdgeState dependencyEdge : incomingEdges) {
            StrictVersionConstraints parentStrictVersionConstraints = notNull(dependencyEdge.getFrom().ownStrictVersionConstraints);
            StrictVersionConstraints parentAncestorsStrictVersionConstraints = notNull(dependencyEdge.getFrom().ancestorsStrictVersionConstraints);
            StrictVersionConstraints parentEndorsedStrictVersionConstraints = getEndorsedStrictVersions(dependencyEdge);

    /**
     * Attributes that match the variant that is consumed.
     *
     * @see org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)
     */
    AttributeContainer getFrom();

    /**
     * Attributes that match the variant that is produced.
     *
     * @see org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)
     */
    AttributeContainer getTo();

/**
 * Registration of an artifact transform.
 */
public interface TransformRegistration {
    /**
     * Attributes that match the variant that is consumed.
     */
    ImmutableAttributes getFrom();

    /**
     * Attributes that match the variant that is produced.
     */
    ImmutableAttributes getTo();

    /**
     * Transform step for artifacts of the variant.
     */