* whose result must be cached even (or specially) at serialization time.
 *
 * @param <T> the resulting type
 */
public abstract class Cached<T> {

    public static <T> Cached<T> of(Callable<T> computation) {
        return new Deferred<>(computation);
    }

    public abstract T get();

    private static class Deferred<T> extends Cached<T> implements java.io.Serializable {

	endpointsliceutil "k8s.io/endpointslice/util"
)

// NewCache returns a new Cache with the specified endpointsPerSlice.
func NewCache(endpointsPerSlice int32) *Cache {
	return &Cache{
		maxEndpointsPerSlice: endpointsPerSlice,
		cache:                map[types.NamespacedName]*EndpointPortCache{},
	}
}

// Cache tracks values for total numbers of desired endpoints as well as the

 * limitations under the License.
 */
package org.gradle.cache;

import javax.annotation.Nullable;
import java.util.function.Function;
import java.util.function.Supplier;

public interface Cache<K, V>  {
    /**
     * Locates the given entry, using the supplied factory when the entry is not present or has been discarded, to recreate the entry in the cache.
     *

# Striped64 appears to make some assumptions about object layout that
# really might not be safe. This should be investigated.
-keepclassmembers class com.google.common.cache.Striped64 {
  *** base;
  *** busy;
}
-keepclassmembers class com.google.common.cache.Striped64$Cell {
  <fields>;

// license that can be found in the LICENSE file.

package ssa

import (
	"cmd/internal/obj"
	"sort"
)

// A Cache holds reusable compiler state.
// It is intended to be re-used for multiple Func compilations.
type Cache struct {
	// Storage for low-numbered values and blocks.
	values [2000]Value
	blocks [200]Block
	locs   [2000]Location

	// Reusable stackAllocState.

        @Override
        void onOpen(Object cache) {
            opened.accept(cache)
        }

        @Override
        void onClose(Object cache) {
            closed.accept(cache)
        }
    }

    def setup() {
        _ * metaDataProvider.processIdentifier >> '123'
        _ * metaDataProvider.processDisplayName >> 'process'
    }

    void "creates directory backed cache instance"() {
        when:

// DO NOT use outside of tests.
func (cache *cacheImpl) NodeCount() int {
	cache.mu.RLock()
	defer cache.mu.RUnlock()
	return len(cache.nodes)
}

// PodCount returns the number of pods in the cache (including those from deleted nodes).
// DO NOT use outside of tests.
func (cache *cacheImpl) PodCount() (int, error) {
	cache.mu.RLock()
	defer cache.mu.RUnlock()

 * limitations under the License.
 */
package org.gradle.cache.internal

import org.gradle.cache.AsyncCacheAccess
import org.gradle.cache.CacheDecorator
import org.gradle.cache.CrossProcessCacheAccess
import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.FileLockReleasedSignal
import org.gradle.cache.IndexedCacheParameters
import org.gradle.cache.LockOptions

beforeSettings { settings ->
    settings.caches {
        releasedWrappers.removeUnusedEntriesAfterDays = 45
        snapshotWrappers.removeUnusedEntriesAfterDays = 10
        downloadedResources.removeUnusedEntriesAfterDays = 45
        createdResources.removeUnusedEntriesAfterDays = 10
        buildCache.removeUnusedEntriesAfterDays = 5
    }

apiVersion: release-notes/v2
kind: feature
area: extensibility
issue: []
releaseNotes:
  - |
    **Improved** Use tag-stripped URL + checksum as a Wasm module cachekey, and the tagged URL is separately cached. 
    This may increase the chance of cache hit (e.g., trying to find the same image with both of the tagged and digest URLs.)