* <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

    @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

     *
     * @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();

    }

    /**

        result != null
        def plannedNodes = result.getExecutionPlan(EnumSet.allOf(NodeIdentity.NodeType))
        plannedNodes.size() == 1
        with(plannedNodes[0]) {
            nodeIdentity.nodeType == NodeIdentity.NodeType.TASK
            (nodeIdentity as CalculateTaskGraphBuildOperationType.TaskIdentity).taskPath == ":t1"
        }
    }

        def identities = ops.collect { op ->
            def plannedNodes = op.result.executionPlan as List<Map<String, ?>>
            def transformStepNodeIdentities = plannedNodes*.nodeIdentity.findAll { it.nodeType == NodeIdentity.NodeType.TRANSFORM_STEP.name() }
            return transformStepNodeIdentities
        }
        def targetColors = (identities.collect { it*.targetAttributes.color }.flatten() as Set<String>)

        )
    }

    def getTypedNodeId(nodeIdentity) {
        switch (nodeIdentity.nodeType) {
            case TASK:
                return new TypedNodeId(nodeType: TASK, nodeIdInType: nodeIdentity.taskId.toString())
            case TRANSFORM_STEP:
                return new TypedNodeId(nodeType: TRANSFORM_STEP, nodeIdInType: nodeIdentity.transformStepNodeId)
            default:

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

package org.gradle.operations.dependencies.transforms;

import org.gradle.internal.taskgraph.NodeIdentity;
import org.gradle.operations.dependencies.configurations.ConfigurationIdentity;
import org.gradle.operations.dependencies.variants.Capability;
import org.gradle.operations.dependencies.variants.ComponentIdentifier;

import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.operations.RunnableBuildOperation;
import org.gradle.internal.operations.trace.CustomOperationTraceSerialization;
import org.gradle.internal.taskgraph.NodeIdentity;

import javax.annotation.Nonnull;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.Collectors;