}

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {
        return true;
    }

    @Override
    public Provider<T> orElse(T value) {
        return this;
    }

    @Override
    public Provider<T> orElse(Provider<? extends T> provider) {
        return this;
    }

            return originMetadata.map(OriginMetadata::getBuildInvocationId).orElse(null);
        }

        @Nullable
        @Override
        public byte[] getOriginBuildCacheKeyBytes() {
            return originMetadata
                .map(OriginMetadata::getBuildCacheKey)
                .map(HashCode::toByteArray)
                .orElse(null);
        }

        @Nullable
        @Override

        this.reusedOutputOriginMetadata = parent.getAfterExecutionOutputState()
            .filter(ExecutionOutputState::isReused)
            .map(ExecutionOutputState::getOriginMetadata)
            .orElse(null);
    }

                .map(PreviousExecutionState::getOutputFilesProducedByWork)
                .orElse(ImmutableSortedMap.of());

            ImmutableSortedMap<String, FileSystemSnapshot> unfilteredOutputSnapshotsBeforeExecution = context.getBeforeExecutionState()
                .map(BeforeExecutionState::getOutputFileLocationSnapshots)
                .orElse(ImmutableSortedMap.of());

        this.validationContext = validationContext;
    }

    protected ExecutionRequestContext(ExecutionRequestContext parent) {
        this(parent.getNonIncrementalReason().orElse(null), parent.getValidationContext());
    }

    /**
     * If incremental mode is disabled, this returns the reason, otherwise it's empty.
     */
    Optional<String> getNonIncrementalReason() {

            public FileSystemNode mergeWithExisting(FileSystemNode child) {
                if (snapshot instanceof FileSystemLocationSnapshot || !child.getSnapshot().map(oldSnapshot -> oldSnapshot instanceof FileSystemLocationSnapshot).orElse(false)) {
                    FileSystemNode newChild = snapshot.asFileSystemNode();
                    diffListener.nodeRemoved(child);
                    diffListener.nodeAdded(newChild);
                    return newChild;

            return this;
        }

        @Override
        public Provider<T> orElse(T value) {
            return Providers.of(value);
        }

        @Override
        public Provider<T> orElse(Provider<? extends T> provider) {
            return Cast.uncheckedCast(provider);
        }

        @Override

        Identity identity = context.getIdentity();
        PreviousExecutionState previousExecutionState = context.getHistory()
            .flatMap(history -> history.load(identity.getUniqueId()))
            .orElse(null);
        R result = delegate.execute(work, new PreviousExecutionContext(context, previousExecutionState));

        // If we did not capture any outputs after execution, remove them from history
        context.getHistory()

        this.executionStateChanges = executionStateChanges;
    }

    protected IncrementalChangesContext(IncrementalChangesContext parent) {
        this(parent, parent.getRebuildReasons(), parent.getChanges().orElse(null));
    }

    /**
     * Returns the reasons to re-execute the work, empty if there's no reason to re-execute.
     */
    public ImmutableList<String> getRebuildReasons() {
        return rebuildReasons;

    }

    public LogLevel getLogLevel() {
        return logLevel;
    }

    public boolean isFailed() {
        return workerProcess.getExecResult().map(execResult -> execResult.getExitValue() != 0).orElse(false);
    }

    public Optional<Integer> getExitCode() {
        return workerProcess.getExecResult().map(ExecResult::getExitValue);
    }

    public boolean isNotExpirable() {
        return cannotBeExpired;