import org.gradle.execution.plan.OrdinalGroupFactory
import org.gradle.execution.plan.ScheduledWork
import org.gradle.execution.plan.TaskNode


class WorkNodeCodec(
    private val owner: GradleInternal,
    private val internalTypesCodec: Codec<Any?>,
    private val ordinalGroups: OrdinalGroupFactory
) {

    suspend fun WriteContext.writeWork(work: ScheduledWork) {

        override val hasScheduledWork: Boolean
            get() = gradle.taskGraph.size() > 0

        override val scheduledWork: ScheduledWork
            get() {
                lateinit var work: ScheduledWork
                gradle.taskGraph.visitScheduledNodes { nodes, entryNodes -> work = ScheduledWork(nodes, entryNodes) }
                return work
            }
    }

    private

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

package org.gradle.internal.cc.impl

import org.gradle.execution.plan.ScheduledWork
import org.gradle.normalization.internal.InputNormalizationHandlerInternal
import org.gradle.util.Path
import java.io.File


/**
 * State cached for a project.
 */
internal

            Set<Task> filteredTasks = contents.getFilteredTasks();
            QueryableExecutionPlan.ScheduledNodes scheduledWork = contents.getScheduledNodes();

            PlannedNodeGraph plannedNodeGraph = computePlannedNodeGraph(scheduledWork);

            buildOperationContext.setResult(new CalculateTaskGraphResult(requestedTasks, filteredTasks, plannedNodeGraph));
        }

import org.gradle.api.internal.GradleInternal;
import org.gradle.api.internal.SettingsInternal;
import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.plan.BuildWorkPlan;
import org.gradle.execution.plan.ScheduledWork;

import javax.annotation.Nullable;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * Controls the lifecycle of an individual build in the build tree.

@NotThreadSafe
public interface ExecutionPlan extends Describable, Closeable {
    void addFilter(Spec<? super Task> filter);

    void setContinueOnFailure(boolean continueOnFailure);

    void setScheduledWork(ScheduledWork work);

    /**
     * Adds an entry task to the execution plan. If called multiple times then execution plan follows the method invocation order.
     *
     */
    void addEntryTask(Task task);

    /**

        return this;
    }

    @Override
    public TaskNode getNode(Task task) {
        return nodeMapping.get(task);
    }

    @Override
    public void setScheduledWork(ScheduledWork work) {
        if (scheduledNodes != null) {
            throw new IllegalStateException("This execution plan already has nodes scheduled.");
        }
        scheduledNodes = work.getScheduledNodes();

import org.gradle.execution.plan.FinalizedExecutionPlan;
import org.gradle.execution.plan.LocalTaskNode;
import org.gradle.execution.plan.QueryableExecutionPlan;
import org.gradle.execution.plan.ScheduledWork;
import org.gradle.initialization.exception.ExceptionAnalyser;
import org.gradle.internal.Describables;
import org.gradle.internal.Pair;
import org.gradle.internal.model.StateTransitionController;

        task.getShouldRunAfter() >> brokenDependencies()
        task.getFinalizedBy() >> taskDependencyResolvingTo(task, [])
        return task
    }

    private ScheduledWork scheduledWork(Node... nodes) {
        return new ScheduledWork(nodes as List<Node>, nodes as List<Node>)
    }