* <p>
 * Needs to be unique across all the execution graphs of the current build.
 *
 * @implNote The implementations must provide value-based equality.
 * @since 8.1
 */
public interface NodeIdentity {

    enum NodeType {
        TASK,
        TRANSFORM_STEP
    }

    NodeType getNodeType();

    private final PlannedTransformStepIdentity identity;
    private final List<? extends NodeIdentity> dependencies;

    public DefaultPlannedTransformStep(
        PlannedTransformStepIdentity identity,
        List<? extends NodeIdentity> dependencies
    ) {
        this.identity = identity;
        this.dependencies = dependencies;
    }

    @Override

        for (PlannedNodeInternal plannedNode : plannedNodes) {
            NodeIdentity nodeIdentity = plannedNode.getNodeIdentity();
            if (!inDetailLevel.test(nodeIdentity)) {
                continue;
            }

            List<? extends NodeIdentity> nodeDependencies = plannedNode.getNodeDependencies();
            if (nodeDependencies.isEmpty() || nodeDependencies.stream().allMatch(inDetailLevel)) {

import org.gradle.internal.taskgraph.NodeIdentity;

import java.util.List;
import java.util.stream.Collectors;

/**
 * Default implementation of {@link PlannedTask}.
 */
public class DefaultPlannedTask implements PlannedTask, PlannedNodeInternal {

    private final TaskIdentity taskIdentity;
    private final List<? extends NodeIdentity> nodeDependencies;
    private final List<TaskIdentity> mustRunAfter;

    static class TestPlannedNode implements PlannedNodeInternal {

        private final TestNodeIdentity nodeIdentity
        private final List<? extends NodeIdentity> dependencies

        TestPlannedNode(TestNodeIdentity nodeIdentity, List<? extends NodeIdentity> dependencies) {
            this.nodeIdentity = nodeIdentity
            this.dependencies = dependencies
        }

        @Override

    @Override
    public Class<? extends Node> getSupportedNodeType() {
        return TransformStepNode.class;
    }

    @Override
    public NodeIdentity.NodeType getConvertedNodeType() {
        return NodeIdentity.NodeType.TRANSFORM_STEP;
    }

    @Override
    public PlannedTransformStepIdentity getNodeIdentity(Node node) {
        TransformStepNode transformStepNode = (TransformStepNode) node;

            throw new UnsupportedOperationException();
        }

        @Override
        public NodeIdentity.NodeType getConvertedNodeType() {
            throw new UnsupportedOperationException();
        }

        @Override
        public NodeIdentity getNodeIdentity(Node node) {
            throw new UnsupportedOperationException();
        }

        @Override

type NodeIdentifier interface {
	// NodeIdentity determines node information from the given user.Info.
	// nodeName is the name of the Node API object associated with the user.Info,
	// and may be empty if a specific node cannot be determined.
	// isNode is true if the user.Info represents an identity issued to a node.
	NodeIdentity(user.Info) (nodeName string, isNode bool)

    @Override
    public Class<? extends Node> getSupportedNodeType() {
        return TaskNode.class;
    }

    @Override
    public NodeIdentity.NodeType getConvertedNodeType() {
        return NodeIdentity.NodeType.TASK;
    }

    @Override
    public TaskIdentity getNodeIdentity(Node node) {
        TaskNode taskNode = (TaskNode) node;

     *
     * @since 8.1
     */
    public interface PlannedNode {

        NodeIdentity getNodeIdentity();

        /**
         * Returns the dependencies of this node.
         * <p>
         * Note that dependencies are not necessarily located in the same execution plan.
         */
        List<? extends NodeIdentity> getNodeDependencies();

    }

    /**