s.cachedVolumeStats.Store(newCache)
}

// GetPodVolumeStats returns the PodVolumeStats for a given pod.  Results are looked up from a cache that
// is eagerly populated in the background, and never calculated on the fly.
func (s *fsResourceAnalyzer) GetPodVolumeStats(uid types.UID) (PodVolumeStats, bool) {
	cache := s.cachedVolumeStats.Load().(statCache)
	statCalc, found := cache[uid]
	if !found {

import org.apache.maven.project.MavenProject;

/**
 * Lifecycle mapping delegate component interface. Calculates project build execution plan given {@link Lifecycle} and
 * lifecycle phase. Standard lifecycles use plugin execution {@code <phase>} or mojo default lifecycle phase to
 * calculate the execution plan, but custom lifecycles can use alternative mapping strategies.
 * <p>

			trace := utiltrace.New(fmt.Sprintf("Calculate volume metrics of %v for pod %v/%v", name, s.pod.Namespace, s.pod.Name))
			defer trace.LogIfLong(1 * time.Second)
			return v.GetMetrics()
		}()
		if err != nil {
			// Expected for Volumes that don't support Metrics
			if !volume.IsNotSupported(err) {

        treeTaskGraphOps.size() == 2
        treeTaskGraphOps[0].displayName == "Calculate build tree task graph"
        treeTaskGraphOps[0].parentId == applyRootProjectBuildScript.id
        treeTaskGraphOps[1].displayName == "Calculate build tree task graph"
        treeTaskGraphOps[1].parentId == root.id

        // The task graph for buildB is calculated multiple times, once for the buildscript dependency and again for the production dependency

 *     However, when the value itself is also calculated from work node outputs, then the provider will carry dependencies on the work nodes that produce the value (as the consumer does care about the value).
 *     </p>

```
modifiedFiles.finalizeValueOnRead()
```

In other words, this method calculates the final value lazily as required, whereas `finalizeValue()` calculates the final value eagerly.
This method can be used when the value may be expensive to calculate or may not have been configured yet.

	// Calculate signature.
	newSignature := getSignature(signingKey, stringToSign)

	// Verify if signature match.
	if !compareSignatureV4(newSignature, signV4Values.Signature) {
		return cred, "", "", time.Time{}, ErrSignatureDoesNotMatch
	}

	// Return calculated signature.
	return cred, newSignature, region, date, ErrNone
}

 *            szDest did not have enough room to hold converted string).
 */

CU_EXPORT size_t CU_translated_strlen(const char *szSrc);
/**< 
 *  Calculates the length of a translated string.
 *  This function calculates the buffer length required to hold a string
 *  after processing with CU_translate_special_characters().  The returned
 *  length does not include space for the terminating '\0' character.  

 */
public interface CppComponent extends ComponentWithBinaries, ComponentWithDependencies, ComponentWithTargetMachines {
    /**
     * Specifies the base name for this component. This name is used to calculate various output file names. The default value is calculated from the project name.
     */
    Property<String> getBaseName();

    /**

     * These are more expensive to calculate than regular inputs as they need to be calculated even if the execution of the work is short circuited by an identity cache.
     * They also cannot reuse snapshots taken during previous executions.
     * Because of these reasons only capture inputs as identity if they are actually used to calculate the identity of the work.