*/
        long getArchiveSize();

    }

    public interface Result {

        /**
         * Whether the entry has actually been stored.
         * <p>
         * The cache might not store some entries, e.g. when they are too large.
         */
        boolean isStored();

    }

    private BuildCacheRemoteStoreBuildOperationType() {
    }

    }

    void substituteForCurrentThread(T substitution) {
        if (threadLocalDecorators.get() != original) {
            throw new IllegalStateException("already substituted for the current thread; proper cleanup might have been missed")
        }
        substitutions.incrementAndGet()
        threadLocalDecorators.set(substitution)
    }

    void cancelSubstitutionForCurrentThread() {

    private final AnsiExecutor ansiExecutor;

    public DefaultTextArea(AnsiExecutor ansiExecutor) {
        this.ansiExecutor = ansiExecutor;
    }

    /**
     * Returns the bottom right position of this text area.
     */
    public Cursor getWritePosition() {
        return writePos;
    }

    public void newLineAdjustment() {
        writePos.row++;
    }

    @Override

import org.gradle.internal.HasInternalProtocol;

/**
 * The version mapping strategy for a publication. By default,
 * Gradle will use the declared versions of a dependency directly. However
 * in some situations it might be better to publish the resolved versions, or both
 * when the metadata format supports it.
 *
 * @since 5.2
 */
@HasInternalProtocol
public interface VersionMappingStrategy {
    /**

            return Class.forName(className) as Class<? extends TestPrecondition>
        } catch (ClassNotFoundException ex) {
            final String message = String.format(
                "Class '%s' cannot be found. You might be missing a dependency in 'subprojects/predicate-tester/builds.gradle.kts'?",
                className
            )
            throw new RuntimeException(message, ex)
        }
    }

    <T> CalculatedValue<T> create(DisplayName displayName, Supplier<? extends T> supplier);

    /**
     * A convenience to create a calculated value that has already been produced.
     * <p>
     * For example, the value might have been restored from the configuration cache.
     */
    <T> CalculatedValue<T> create(DisplayName displayName, T value);

    /**
     * Creates a cache backed by calculated values.
     */

class SerializedIsolatedActionGraph<G>(
    /**
     * The serialized graph.
     */
    val graph: ByteArray,

    /**
     * External references that are not serialized directly as part of the [graph].
     * These might include references to classes, value sources and build services.
     *
     * Maps the integer written to the serialized [graph] to the external reference.
     * See [EnvironmentEncoder] and [EnvironmentDecoder] for details.

            "0" -> {
                // When testing against a `major.0` snapshot we need to take into account
                // that source distributions matching the major version might not have
                // been published yet. In that case we adjust the constraint to include
                // source distributions beginning from the previous major version.
                "${previous(major)}.0"

        for (int i = 0; i < result.length; ++i) {
            // The elements of result have to be of some subtype of E because of Set's invariant,
            // so the inner cast is safe. The outer cast might be problematic if T is a some subtype
            // of E and the factory function returns some other subtype. However, this is unlikely
            // to happen in our use cases. Only System.getProperties().entrySet implementation uses

     * viewed as. In other words this is the full list of interfaces that a view proxy class generated for this struct type might implement.
     *
     * <p>Note: currently view proxies also implement any interfaces implemented by the delegate type. The set returned by this method