cb.fetchFirst(ComponentUtil.getFessConfig().getPageKeymatchMaxFetchSizeAsInteger());
        });
    }

    /**
     * Loads KeyMatch settings from the database and builds a query map.
     *
     * @return The number of loaded KeyMatch settings.
     */
    @Override
    public int load() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

    CountingLoader loader = new CountingLoader();
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
    assertThat(loader.getCount()).isEqualTo(0);

    Object key = new Object();
    Object value = map.get(key, loader);
    assertThat(loader.getCount()).isEqualTo(1);
    assertThat(map.get(key, loader)).isEqualTo(value);
    assertThat(loader.getCount()).isEqualTo(1);
  }

    CountingLoader loader = new CountingLoader();
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
    assertThat(loader.getCount()).isEqualTo(0);

    Object key = new Object();
    Object value = map.get(key, loader);
    assertThat(loader.getCount()).isEqualTo(1);
    assertThat(map.get(key, loader)).isEqualTo(value);
    assertThat(loader.getCount()).isEqualTo(1);
  }

        CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
      localCache = new LocalCache<K, V>(builder, loader);
    }

    // Cache methods

    @Override
    public V get(K key, Callable<? extends V> valueLoader) throws ExecutionException {
      synchronized (localCache.lock) { // Prevent concurrent loads for the same key
        V value = localCache.get(key);
        if (value != null) {

   * {@link CacheLoader#load} calls to {@code loader}.
   */
  static <K, V> CacheLoader<K, V> bulkLoader(CacheLoader<K, V> loader) {
    checkNotNull(loader);
    return new CacheLoader<K, V>() {
      @Override
      public V load(K key) throws Exception {
        return loader.load(key);
      }

      @Override

   *
   * @param loader the cache loader used to obtain new values
   * @return a cache having the requested features
   */
  public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(
      CacheLoader<? super K1, V1> loader) {
    checkWeightWithWeigher();
    return new LocalCache.LocalLoadingCache<>(this, loader);
  }

  /**

  public void testBulkLoad_loadAll() throws ExecutionException {
    IdentityLoader<Integer> backingLoader = identityLoader();
    CacheLoader<Integer, Integer> loader = bulkLoader(backingLoader);
    LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().recordStats().build(loader);
    CacheStats stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(0);
    assertThat(stats.loadSuccessCount()).isEqualTo(0);

 * loader. That way, this class doesn't prevent the main class loader from getting garbage
 * collected, and this class can detect when the main class loader has been garbage collected and
 * stop itself.
 */
public class Finalizer implements Runnable {

  private static final Logger logger = Logger.getLogger(Finalizer.class.getName());

  /**

  public void testBulkLoad_loadAll() throws ExecutionException {
    IdentityLoader<Integer> backingLoader = identityLoader();
    CacheLoader<Integer, Integer> loader = bulkLoader(backingLoader);
    LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().recordStats().build(loader);
    CacheStats stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(0);
    assertThat(stats.loadSuccessCount()).isEqualTo(0);

        assertArgumentNotNull("loader", loader);

        if (path == null || loader == null) {
            return null;
        }
        final String p = getResourcePath(path, extension);
        return loader.getResource(p);
    }

    /**
     * Returns the resource as a stream from the context class loader.
     *
     * @param path