}
            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")

    private final DisplayName displayName;
    // Null when the value has been calculated and assigned to the result field. When not null the result has not been calculated
    // or is currently being calculated or has just been calculated. It is possible for both this field and the result field to be
    // non-null at the same time for a brief period just after the result has been calculated
    @Nullable
    private volatile CalculationState<T, S> calculationState;

  MinMax calibration calculates the global min and global max values.

  global min = min of given sample inputs
  global max = max of given sample inputs
  """

  def get_min_max_value(self) -> tuple[float, float]:
    """Calculates the global min and max values.

    Returns:
      (min_value, max_value): Min and max calculated using MinMax
    """
    return (

	}

	// ba.score favors nodes with balanced resource usage rate.
	// It calculates the standard deviation for those resources and prioritizes the node based on how close the usage of those resources is to each other.
	// Detail: score = (1 - std) * MaxNodeScore, where std is calculated by the root square of Σ((fraction(i)-mean)^2)/len(resources)
	// The algorithm is partly inspired by:

/**
 * Some value that is calculated as part of dependency resolution, but which may have a partial or different value
 * when the execution graph is calculated.
 * @param <T>
 */
public interface ResolutionResultProvider<T> {

    /**
     * Returns the value available at execution graph calculation time. Note that the value may change between when the execution graph is calculated and