}

    Set<EdgeState> getIncomingEdges() {
        Set<EdgeState> incoming = new LinkedHashSet<>();
        if (selected != null) {
            for (NodeState nodeState : selected.getNodes()) {
                incoming.addAll(nodeState.getIncomingEdges());
            }
        }
        return incoming;
    }

    VirtualPlatformState getPlatformState() {
        if (platformState == null) {

import org.gradle.api.internal.tasks.TaskDependencyResolveContext;

import javax.annotation.Nullable;
import java.util.HashSet;
import java.util.Set;

/**
 * A {@link TaskDependencyResolveContext} which visits incoming dependencies if they are {@link TaskDependencyContainer} instances.
 */
public abstract class AbstractTaskDependencyContainerVisitingContext extends AbstractTaskDependencyResolveContext {

        buildFile << """
            task check${name} {
                def files = configurations.${name}
                def incomingFiles = files.incoming.files
                def artifactFiles = files.incoming.artifactView{}.files
                def artifacts = files.incoming.artifactView{}.artifacts
                doLast {
                    assert files.collect { it.name } == [${fileNames}]

                    }
                }
                ["blue", "green"].each { type ->
                    tasks.register("resolve\${type.capitalize()}") {
                        def artifacts = configurations.compile.incoming.artifactView {
                            attributes { it.attribute(artifactType, type) }
                        }.artifacts

                        inputs.files artifacts.artifactFiles

        repo.createLightWeightTag("1.2")
        dependency(dependencyName)

        buildFile << """
            classes.doLast {
                def components = configurations.runtimeClasspath.incoming.resolutionResult.allComponents.id
                assert components.size() == 3
                assert components[0].build.buildPath == ':'
                assert components[0].build.name == ':'

 * limitations under the License.
 */
package org.gradle.api;

/**
 * <p>A {@code Transformer} transforms objects of type.</p>
 *
 * <p>Implementations are free to return new objects or mutate the incoming value.</p>
 *
 * @param <OUT> The type the value is transformed to.
 * @param <IN> The type of the value to be transformed.
 */
public interface Transformer<OUT extends @org.jetbrains.annotations.Nullable Object, IN> {

    }
    tasks.named<Jar>("sourcesJar") {
        from(sourcesPath.incoming.artifactView { lenient(true) }.files)
    }
    val sourcesElements by configurations
    sourcesElements.attributes {
        attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.SHADOWED))
    }
}

fun Configuration.artifactViewForType(artifactTypeName: String) = incoming.artifactView {

	return &DebugGen{
		Server:          s,
		SystemNamespace: systemNamespace,
		DebugMux:        debugMux,
	}
}

// Generate XDS debug responses according to the incoming debug request
func (dg *DebugGen) Generate(proxy *model.Proxy, w *model.WatchedResource, req *model.PushRequest) (model.Resources, model.XdsLogDetails, error) {
	if err := validateProxyAuthentication(proxy, w); err != nil {

    @Override
    public void execute(final ConflictResolutionResult result) {
        result.withParticipatingModules(moduleIdentifier -> {
            // Restart each configuration. For the evicted configuration, this means moving incoming dependencies across to the
            // matching selected configuration. For the select configuration, this mean traversing its dependencies.
            resolveState.getModule(moduleIdentifier).replaceWith(result.getSelected());

 *
 * <p>A {@code Transformer} transforms objects of type.</p>
 *
 * <p>Implementations are free to return new objects or mutate the incoming value.</p>
 *
 * @param <OUT> The type the value is transformed to.
 * @param <IN> The type of the value to be transformed.
 */
public interface InternalTransformer<OUT, IN> {
    /**