* limitations under the License.
 */

package org.gradle.caching;

/**
 * Cache key identifying an entry in the build cache.
 *
 * @since 3.3
 */
public interface BuildCacheKey {
    /**
     * Returns the string representation of the cache key.
     */
    String getHashCode();

    /**
     * Returns the byte array representation of the cache key.
     *
     * @since 5.4

            this.preposition = preposition;
        }

        public String describe(BuildCacheKey key, BuildCacheServiceRole role) {
            return capitalizedVerb + " entry " + key.getHashCode() + " " + preposition + " " + role.getDisplayName() + " build cache";
        }

        public String describeFailure(BuildCacheKey key, BuildCacheServiceRole role) {

public class OriginMetadata {

    private final String buildInvocationId;
    private final HashCode buildCacheKey;
    private final Duration executionTime;

    public OriginMetadata(String buildInvocationId, HashCode buildCacheKey, Duration executionTime) {
        this.buildInvocationId = buildInvocationId;
        this.buildCacheKey = buildCacheKey;
        this.executionTime = executionTime;
    }

    public String getBuildInvocationId() {

            public class Main {}
        """

        when:
        executer.expectDeprecationWarning("The BuildCacheKey.getDisplayName() method has been deprecated. This is scheduled to be removed in Gradle 9.0. Please use the getHashCode() method instead.")
        executer.expectDeprecationWarning("The BuildCacheKey.getDisplayName() method has been deprecated. This is scheduled to be removed in Gradle 9.0. Please use the getHashCode() method instead.")

import org.gradle.caching.BuildCacheKey;
import org.gradle.caching.internal.operations.BuildCacheRemoteLoadBuildOperationType;

public class LoadOperationDetails implements BuildCacheRemoteLoadBuildOperationType.Details {

    private final BuildCacheKey buildCacheKey;

    public LoadOperationDetails(BuildCacheKey buildCacheKey) {
        this.buildCacheKey = buildCacheKey;
    }

    @Override

        @Override
        void storeLocally(BuildCacheKey key, File file) {

        }

        @Override
        void loadLocally(BuildCacheKey key, Consumer<? super File> reader) {
        }

        @Override
        boolean load(BuildCacheKey key, BuildCacheEntryReader reader) throws BuildCacheException {
            return false
        }

import org.gradle.caching.BuildCacheKey;
import org.gradle.caching.internal.operations.BuildCacheRemoteStoreBuildOperationType;

public class StoreOperationDetails implements BuildCacheRemoteStoreBuildOperationType.Details {

    private final BuildCacheKey cacheKey;
    private final long archiveSize;

    public StoreOperationDetails(BuildCacheKey cacheKey, long archiveSize) {
        this.cacheKey = cacheKey;

     *
     * @param key the cache key.
     * @return {code true} if the entry exists in the cache.
     */
    boolean contains(BuildCacheKey key);

    @Override
    default void store(BuildCacheKey key, BuildCacheEntryWriter legacyWriter) throws BuildCacheException {
        NextGenWriter writer;
        if (legacyWriter instanceof NextGenWriter) {

        this.delegate = delegate;
    }

    public static CachingState enabled(BuildCacheKey key, BeforeExecutionState beforeExecutionState) {
        return new CachingState(Either.left(new Enabled(key, beforeExecutionState)));
    }

    public static CachingState disabled(ImmutableList<CachingDisabledReason> disabledReasons, @Nullable BuildCacheKey key, @Nullable BeforeExecutionState beforeExecutionState) {

        def firstBuildCacheKey = buildCacheKey(":write")
        originBuildInvocationId(":write") == null

        when:
        succeeds "clean", "write"

        then:
        skipped ":write"
        def secondBuildId = buildInvocationId
        firstBuildId != secondBuildId
        with(origin(":write")) {
            buildInvocationId == firstBuildId
            buildCacheKey == firstBuildCacheKey
        }