}

    public Optional<InputChangesInternal> getInputChanges() {
        return Optional.ofNullable(inputChanges);
    }

    public boolean isIncrementalExecution() {
        return inputChanges != null && inputChanges.isIncremental();
    }

    @Override
    public CachingState getCachingState() {
        return cachingState;
    }

     */
    Optional<OriginMetadata> getReusedOutputOriginMetadata();

    /**
     * The caching state of the task, including all its captured inputs and the cache key if calculated.
     */
    CachingState getCachingState();

    TaskExecuterResult WITHOUT_OUTPUTS = new TaskExecuterResult() {
        @Override
        public List<String> getExecutionReasons() {
            return ImmutableList.of();
        }

        @Override

        this.cachingState = cachingState;
    }

    protected CachingResult(CachingResult parent) {
        this(parent, parent.getCachingState());
    }

        super(parent);
        this.cachingState = cachingState;
    }

    /**
     * The resolved state of caching for the work.
     */
    @Override
    public CachingState getCachingState() {
        return cachingState;
    }

            public List<String> getExecutionReasons() {
                return result.getExecutionReasons();
            }

            @Override
            public CachingState getCachingState() {
                return result.getCachingState();
            }
        };
    }

    private static TaskExecutionOutcome convertOutcome(ExecutionOutcome model) {
        switch (model) {
            case FROM_CACHE:

import org.gradle.internal.execution.caching.CachingState;

public interface CachingContext extends Context {
    /**
     * The resolved state of caching for the work.
     */
    CachingState getCachingState();

        super(parent);
        this.cachingState = cachingState;
    }

    /**
     * The resolved state of caching for the work.
     */
    @Override
    public CachingState getCachingState() {
        return cachingState;
    }

        this.delegate = delegate;
    }

    @Override
    public R execute(UnitOfWork work, C context) {
        return delegate.execute(work, new InputChangesContext(context, null, context.getCachingState()));
    }

        this.delegate = delegate;
    }

    @Override
    public R execute(UnitOfWork work, C context) {
        work.markLegacySnapshottingInputsFinished(context.getCachingState());
        return delegate.execute(work, context);
    }

    }

    @Override
    public R execute(UnitOfWork work, C context) {
        return delegate.execute(work, new InputChangesContext(context, determineInputChanges(work, context), context.getCachingState()));
    }

    @Nullable
    private static InputChangesInternal determineInputChanges(UnitOfWork work, IncrementalChangesContext context) {
        if (work.getExecutionBehavior() == NON_INCREMENTAL) {