* 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.
 *
 * <p>The {@code getInputStream()} method provides an InputStream to read the cached content.

import org.lastaflute.web.Execute;
import org.lastaflute.web.response.ActionResponse;
import org.lastaflute.web.response.StreamResponse;

/**
 * Action class for handling cached document content requests.
 * Provides functionality to retrieve and display cached versions of crawled documents.
 */
public class CacheAction extends FessSearchAction {

    /**
     * Creates a new instance of CacheAction.
     */

        return leaseEntry != null && leaseEntry.hasReadCache();
    }

    /**
     * Get cached directory listing
     *
     * @param directoryPath directory path
     * @return list of cached files or null
     */
    public List<SmbFile> getCachedDirectoryListing(String directoryPath) {
        DirectoryCacheEntry entry = getCacheEntry(directoryPath);

        byte[] third = impl.getBuffer(); // cache empty -> new with size 3

        assertSame(a, first, "First get should return first cached buffer");
        assertSame(c, second, "Second get should return second cached buffer");
        assertNotSame(d, third, "Third get should allocate a new buffer (not the dropped one)");

    public static final int DIRECTORY_FULL = Smb2LeaseState.SMB2_LEASE_FULL;

    /**
     * Check if directory can cache enumeration results
     * @param state lease state
     * @return true if directory enumeration can be cached
     */
    public static boolean canCacheEnumeration(int state) {
        return Smb2LeaseState.hasReadCaching(state);
    }

    /**
     * Check if directory can keep handles open

        String directoryPath = smbFile.getPath();

        // Check if we can use cached directory listing
        if (dirManager.canCacheDirectoryListing(directoryPath)) {
            List<SmbFile> cachedFiles = dirManager.getCachedDirectoryListing(directoryPath);
            if (cachedFiles != null) {
                log.debug("Using cached directory listing for: {}", directoryPath);

        assertTrue(connection instanceof NtlmHttpURLConnection, "Should use cached handler and wrap it.");
    }

    @Test
    void testOpenConnection_CachedHandler_ReusesExistingHandler() throws Exception {
        // This test verifies that once a handler is cached, subsequent calls reuse it.
        setupMockProtocolHandlers();
        URL url1 = new URL("http://example.com/resource1");

        directoryLeaseManager.requestDirectoryLease(directoryPath, DirectoryLeaseState.DIRECTORY_READ_HANDLE,
                DirectoryCacheScope.IMMEDIATE_CHILDREN);

        // No cached listing initially
        assertNull(directoryLeaseManager.getCachedDirectoryListing(directoryPath));

        // Setup mock files
        when(mockFile1.getName()).thenReturn("file1.txt");

 * including tracking information for optimistic locking and audit trails.
 * Key matches are used to promote specific documents when certain keywords are searched.
 */
public class EditForm extends CreateForm {

    /**
     * Creates a new EditForm instance.
     */
    public EditForm() {
        super();
    }

    /**

        if (cookieNameMap == null) {
            cookieNameMap = new HashMap<>();
        }
        cookieNameMap.put(cookieName, roleName);
    }

    /**
     * Sets the cached cipher.
     * @param cipher The cached cipher.
     */
    public void setCipher(final CachedCipher cipher) {
        this.cipher = cipher;
    }

    /**
     * Sets the value separator.