}

        /**
         * Gets the name of this cached file or directory
         * @return the file name
         */
        public String getName() {
            return name;
        }

        /**
         * Gets the size of this cached file in bytes
         * @return the file size
         */
        public long getSize() {

	t.Once.Do(func() {
		t.ttl = ttl
		t.updateFn = update
		t.opts = opts
	})
}

// GetWithCtx will return a cached value or fetch a new one.
// passes a caller context, if caller context cancels nothing
// is cached.
// If the Update function returns an error the value is forwarded as is and not cached.
func (t *Cache[T]) GetWithCtx(ctx context.Context) (T, error) {
	v := t.val.Load()
	ttl := t.ttl
	vTime := t.lastUpdateMs.Load()

            assertSame(cachedOrig, copySubj, "Clone should share the cached Subject reference");

            // Refreshing the original must not clear the clone's cached subject
            orig.refresh();
            // Clone should retain its cached Subject
            assertSame(copySubj, copy.getSubject(), "Clone should retain its cached Subject");
        } else {

The [Hasher] interface type defines the contract between values of a
particular type and future hash-based data structures such as hash

import jcifs.smb1.smb1.SmbAuthException;
import jcifs.smb1.smb1.SmbSession;
import jcifs.smb1.util.Base64;
import jcifs.smb1.util.LogStream;

/**
 * This servlet Filter can be used to negotiate password hashes with
 * MSIE clients using NTLM SSP. This is similar to {@code Authentication:
 * BASIC} but weakly encrypted and without requiring the user to re-supply
 * authentication credentials.
 * <p>

     * for this session, the result will be cached and subsequent identical requests will return the cached
     * value without re-executing the supplier.
     * <p>
     * The caching behavior is determined by the cache retention specified in the request's metadata.
     * If an error occurs during execution, it will be cached and re-thrown for subsequent identical requests.
     *

     * first initiated.
     */
    private var sentRequestMillis = 0L

    /**
     * Extension header set by OkHttp specifying the timestamp when the cached HTTP response was
     * first received.
     */
    private var receivedResponseMillis = 0L

    /** Etag of the cached response. */
    private var etag: String? = null

    /** Age of the cached response. */

 *   <li>In-memory caching using a byte array</li>
 *   <li>File-based caching using a File object</li>
 * </ul>
 *
 * <p>When an instance of ContentCache is created with a byte array, the content is cached in memory.
 * When an instance is created with a File object, the content is cached in the specified file.
 *
 * <p>The {@code close()} method deletes the file if the content is cached in a file.
 *

		return selected, true
	}

	// If cached is nil we shall skip the entry.
	if selected.cached == nil {
		return nil, false
	}

	// Merge if we have disagreement.
	// Create a new merged result.
	selected = &metaCacheEntry{
		name:     selected.name,
		reusable: true,
		cached:   &xlMetaV2{metaV: selected.cached.metaV},
	}

        // Verify each method exists
        boolean hasGet = false, hasPost = false, hasPut = false, hasDelete = false;
        boolean hasHead = false, hasOptions = false, hasTrace = false, hasConnect = false;

        for (final Method method : methods) {
            switch (method) {
            case GET:
                hasGet = true;
                break;
            case POST: