plan := a.PlanFor(arch).Find(args.Name)
				if plan == nil {
					continue
				}
				// Plan is a list of real file paths, but we don't have a strong mapping from "docker context source"
				// to "real path on disk". We do have a weak mapping though, by reproducing docker-copy.sh
				for dest, src := range args.Files {
					translated, err := translate(plan.Dependencies(), src)
					if err != nil {

}

// Data reads and returns the contents of the Plan 9 a.out section.
func (s *Section) Data() ([]byte, error) {
	return saferio.ReadDataAt(s.sr, uint64(s.Size), 0)
}

// Open returns a new ReadSeeker reading the Plan 9 a.out section.
func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) }

// A Symbol represents an entry in a Plan 9 a.out symbol table section.
type Sym struct {
	Value uint64

func (c *configFactory) New() config.Plan {
	return &configPlan{
		configFactory: c,
		yamlText:      make(map[string][]string),
	}
}

func (c *configFactory) YAML(ns string, yamlText ...string) config.Plan {
	return c.New().YAML(ns, yamlText...)
}

func (c *configFactory) Eval(ns string, args any, yamlTemplates ...string) config.Plan {
	return c.New().Eval(ns, args, yamlTemplates...)
}

 * limitations under the License.
 */
package org.gradle.execution.taskgraph;

import org.gradle.api.Task;
import org.gradle.api.execution.TaskExecutionGraph;
import org.gradle.execution.plan.FinalizedExecutionPlan;
import org.gradle.execution.plan.Node;
import org.gradle.internal.build.ExecutionResult;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;

import org.gradle.api.internal.project.taskfactory.TestTaskIdentities
import org.gradle.execution.plan.ExecutionPlan
import org.gradle.execution.plan.LocalTaskNode
import org.gradle.execution.plan.QueryableExecutionPlan
import org.gradle.execution.plan.ToPlannedNodeConverterRegistry
import org.gradle.execution.plan.ToPlannedTaskConverter
import org.gradle.internal.operations.TestBuildOperationRunner

 */
class ForceConnectRoutePlanner(private val delegate: RealRoutePlanner) : RoutePlanner by delegate {
  override fun plan(): RoutePlanner.Plan = delegate.planConnect() // not delegate.plan()

     */
    void prepareToScheduleTasks();

    /**
     * Creates a new work plan for this build. This method can be called multiple times to create multiple plans.
     */
    BuildWorkPlan newWorkGraph();

    /**
     * Populates the given work plan with tasks and work from this build.
     */
    void populateWorkGraph(BuildWorkPlan plan, Consumer<? super WorkGraphBuilder> action);

    /**

    }

    @Override
    public void scheduleRequestedTasks(GradleInternal gradle, @Nullable EntryTaskSelector selector, ExecutionPlan plan) {
        gradle.getOwner().getProjects().withMutableStateOfAllProjects(() -> {
            buildTaskScheduler.scheduleRequestedTasks(gradle, selector, plan);

            if (buildModelParameters.isConfigureOnDemand() && gradle.isRootBuild()) {

    }

    /**
     * Is the grammar file modeled by this plan out of considered out of date?
     *
     * @return True if the grammar generation is out of date (needs regen); false otherwise.
     */
    public boolean isOutOfDate() {
        return outOfDate;
    }

    /**
     * Marks the plan as out of date.
     */
    void markOutOfDate() {
        this.outOfDate = true;
    }

            delegate.prepareToScheduleTasks()
        } // Else, already done
    }

    override fun scheduleRequestedTasks(selector: EntryTaskSelector?, plan: ExecutionPlan) {
        if (!maybeLoadFromCache()) {
            delegate.scheduleRequestedTasks(selector, plan)
        } // Else, already scheduled
    }

    private
    fun maybeLoadFromCache(): Boolean {
        return configurationCache.isLoaded
    }