cb.query().setRequestedAt_LessEqual(systemHelper.getCurrentTimeAsLocalDateTime().minusDays(days));
        });
    }

    /**
     * Retrieves a list of search logs based on the specified pager criteria.
     *
     * This method supports various log types including search logs, click logs,
     * favorite logs, user information, and different aggregation types for analytics.
     *

        return queryString;
    }

    /**
     * Checks if role-based query filtering is enabled.
     * @return True if role query is enabled, false otherwise.
     */
    public boolean roleQueryEnabled() {
        return !disableRoleQuery;
    }

    /**
     * Disables role-based query filtering for this context.
     */
    public void skipRoleQuery() {

    }

    /**
     * Returns a {@link Traverser} that handles a collection of classes or resources based on the specified directory.
     *
     * @param rootDir
     *            The root directory. Must not be {@literal null} or an empty string.
     * @return A {@link Traverser} that handles a collection of classes or resources based on the specified directory.
     */
    public static Traverser getTraverser(final String rootDir) {

    /**
     * Removes a stored crawling configuration from the session-based storage.
     *
     * @param sessionCountId the session count ID of the configuration to remove
     */
    public void remove(final String sessionCountId) {
        crawlingConfigMap.remove(sessionCountId);
    }

    /**
     * Retrieves a stored crawling configuration from the session-based storage.
     *

     * Used to access various configuration settings like paging parameters.
     */
    @Resource
    protected FessConfig fessConfig;

    /**
     * Retrieves a paginated list of related queries based on the provided pager parameters.
     * This method performs a database query with pagination and updates the pager with result information.
     *

	maxDuration                        = math.MaxInt64
	maxDynamicTimeout                  = 24 * time.Hour // Never set timeout bigger than this.
)

// timeouts that are dynamically adapted based on actual usage results
type dynamicTimeout struct {
	timeout       int64
	minimum       int64
	entries       int64
	log           [dynamicTimeoutLogSize]time.Duration
	mutex         sync.Mutex

            return 1.0;
        }

        // Simple heuristic based on data entropy
        // In practice, this would be more sophisticated
        int uniqueBytes = countUniqueBytes(data);
        double entropy = (double) uniqueBytes / 256.0;

        // Estimate compression ratio based on entropy
        // Lower entropy = better compression

 * It implements the Closeable interface to ensure that resources are properly released.
 *
 * <p>This class supports two types of content caching:
 * <ul>
 *   <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.

import java.io.InputStream;
import java.nio.file.Files;

import org.codelibs.curl.Curl;
import org.junit.After;
import org.junit.Test;

/**
 * Test class for ContentCache.
 * Tests memory-based and file-based content caching.
 */
public class ContentCacheTest {

    private File tempFile;

    @After
    public void tearDown() {
        if (tempFile != null && tempFile.exists()) {

 * in a large index without loading all of them into memory at once.
 * </p>
 *
 * <p>
 * The reader supports limiting the number of documents read based on a percentage of the total documents
 * or a fixed number. It also allows filtering documents based on their size, using the {@code limitOfDocumentSize}
 * parameter.
 * </p>
 *
 * <p>