}
            ImmutableList<ResourcePattern> artifactResources = artifactResourcesBuilder.build();

            String id = calculateId(MavenResolver.class, metadataResources, artifactResources, metadataSources, hasher -> {});

            return new MavenRepositoryDescriptor(
                id,
                checkNotNull(name),
                url,

            this.authenticationSchemes = ImmutableList.copyOf(authenticationSchemes);
            return self();
        }

        protected String calculateId(
            Class<? extends ExternalResourceResolver> implementation,
            List<ResourcePattern> metadataResources,
            List<ResourcePattern> artifactResources,
            List<String> metadataSources,

            ImmutableList<ResourcePattern> effectiveIvyResources = ivyResourcesBuilder.build();
            ImmutableList<ResourcePattern> effectiveArtifactResources = artifactResourcesBuilder.build();

            String id = calculateId(IvyResolver.class, effectiveIvyResources, effectiveArtifactResources, metadataSources, hasher -> hasher.putBoolean(m2Compatible));

            return new IvyRepositoryDescriptor(
                id,

    @Nonnull
    Map<ChecksumAlgorithm, String> calculate(@Nonnull byte[] data, @Nonnull Collection<ChecksumAlgorithm> algorithms);

    /**
     * Calculates checksums for specified data.
     *
     * @param data        The content for which to calculate checksums, must not be {@code null}.
     * @param algorithms  The checksum algorithms to use, must not be {@code null}.
     * @return The calculated checksums, indexed by algorithms, never {@code null}.

     */
    Try<T> getValue() throws IllegalStateException;

    /**
     * Returns true if this value is already calculated.
     * Note that some other thread may currently be calculating the value even if this method returns false.
     */
    boolean isFinalized();

    /**
     * Calculates the value, if not already calculated. Collects any exception and does not rethrow them.

        1 * fileSystemAccess.readRegularFileContentHash(file.absolutePath) >> Optional.empty()
        1 * calculator.calculate(file, false) >> 12
        0 * _

        when:
        result = cache.get(file)

        then:
        result == 12
        0 * _
    }

    def "reuses calculated value for file across cache instances"() {
        def file = new File("thing.txt")

        e.message == 'Value for <thing> has not been calculated yet.'

        when:
        container.getValue().get()

        then:
        def e2 = thrown(IllegalStateException)
        e2.message == 'Value for <thing> has not been calculated yet.'
    }

    def "at most one thread calculates the value"() {
        // Don't use a spock mock as these apply their own synchronization

     */
    void finalizeValue();

    /**
     * Requests that the final value of this object be calculated on the next read of the value, if not already known.
     *
     * <p>Changes to the value of this object or to the source for the value are still permitted until the final value is calculated, after which time attempts to make changes will fail with an exception.</p>
     *

	"k8s.io/apiserver/pkg/admission"
	"k8s.io/client-go/tools/cache"
)

// UsageStatsOptions is an options structs that describes how stats should be calculated
type UsageStatsOptions struct {
	// Namespace where stats should be calculate
	Namespace string
	// Scopes that must match counted objects
	Scopes []corev1.ResourceQuotaScope
	// Resources are the set of resources to include in the measurement

    /**
     * Creates a {@link FileCollection} that represents some task input that is calculated from one or more other file collections.
     *
     * <p>The implementation applies caching to the result, so that the matching files are calculated during file snapshotting and the result cached in memory for when it is queried again, either during task action execution or in order to calculate some other task input value.
     *