*
 * In the external resource example, a record may consist of the external resource URI and
 * the external resource text. Then when we need to check if the resource is up-to-date,
 * we can ask the service by calling {@code isUpToDate(IN, OUT)} with
 * the URI as an input.
 *
 * It's up to the service implementation to determine:
 *
 * - the type of the input which allows requesting its up-to-date ness ({@link IN}

        this.skipped = skipped;
        this.upToDate = upToDate;
        this.message = message;
    }

    public boolean isSkipped() {
        return skipped;
    }

    public boolean isUpToDate() {
        return upToDate;
    }

    @Nullable
    public String getMessage() {
        return message;
    }

        super(startTime, endTime);
        this.upToDate = upToDate;
        this.fromCache = fromCache;
        this.taskExecutionDetails = taskExecutionDetails;
    }

    @Override
    public boolean isUpToDate() {
        return this.upToDate;
    }

    @Override
    public boolean isFromCache() {
        return fromCache;
    }

    @Override
    public boolean isIncremental() {

    /**
     * Returns whether this task was up-to-date.
     *
     * @return {@code true} if this task was up-to-date
     */
    boolean isUpToDate();

    public DefaultJavaCompileTaskSuccessResult(DefaultTaskSuccessResult delegate, List<InternalAnnotationProcessorResult> annotationProcessorResults) {
        super(delegate.getStartTime(), delegate.getEndTime(), delegate.isUpToDate(), delegate.isFromCache(), delegate.getOutcomeDescription(), delegate.isIncremental(), delegate.getExecutionReasons());
        this.annotationProcessorResults = annotationProcessorResults;
    }

    @Nullable

public interface TaskSuccessResult extends TaskExecutionResult, SuccessResult {
    /**
     * Returns whether this task was up-to-date.
     *
     * @return {@code true} if this task was up-to-date
     */
    boolean isUpToDate();

    /**
     * Returns whether the output for this task was pulled from a build cache when using

        super(startTime, endTime, outcomeDescription, incremental, executionReasons);
        this.upToDate = upToDate;
        this.fromCache = fromCache;
    }

    @Override
    public boolean isUpToDate() {
        return upToDate;
    }

    @Override
    public boolean isFromCache() {
        return fromCache;
    }

func (v *VersionFile) Write(vp *EtcdVersionPair) error {
	// We do write only if file content differs from given EtcdVersionPair.
	isUpToDate, err := v.equals(vp)
	if err != nil {
		return fmt.Errorf("failed to to check if version file %s should be changed: %v", v.path, err)
	}
	if isUpToDate {
		return nil
	}
	// We do write + rename instead of just write to protect from version.txt
	// corruption under full disk condition.

    private val externalResourceConnector: ExternalResourceConnector,
    private val cachedExternalResourceIndex: CachedExternalResourceIndex<String>
) {

    fun isUpToDate(uri: URI): Boolean =
        if (startParameter.isOffline) {
            true
        } else {
            val externalResourceName = ExternalResourceName(uri)

    override val collectedInformation: Serializable = cacheMiss

    override fun action(taskPath: String, taskResult: TaskOperationResult) {
        if (taskResult is TaskSuccessResult && !taskResult.isFromCache && !taskResult.isUpToDate) {
            println("CACHE_MISS in task $taskPath")
            cacheMiss.set(true)
        }
    }
}


/**