return statsCounterSupplier;
  }

  /**
   * Builds a cache, which either returns an already-loaded value for a given key or atomically
   * computes or retrieves it using the supplied {@code CacheLoader}. If another thread is currently
   * loading the value for this key, simply waits for that thread to finish and returns its loaded
   * value. Note that multiple threads can concurrently load values for distinct keys.
   *

    private static final Logger logger = LogManager.getLogger(StemmerOverrideFile.class);

    private static final String STEMMER_OVERRIDE = "stemmeroverride";

    /** The list of stemmer override items loaded from the dictionary file. */
    List<StemmerOverrideItem> stemmerOverrideItemList;

    /**
     * Constructs a new stemmer override file.
     *
     * @param id        The unique identifier for this dictionary file.

        } catch (Exception e) {
            // Ignore cleanup errors
        }
        suggester.shutdown();
    }

    /**
     * Test that resource files can be loaded successfully.
     * This indirectly tests getDefaultMappings and getDefaultIndexSettings.
     */
    @Test
    public void testResourceLoading_viaIndexCreation() throws Exception {

   * Hashing} class is loaded. <b>Do not use this method</b> if hash codes may escape the current
   * process in any way, for example being sent over RPC, or saved to disk. For a general-purpose,
   * non-cryptographic hash function that will never change behavior, we suggest {@link
   * #murmur3_128}.
   *
   * <p>Repeated calls to this method on the same loaded {@code Hashing} class, using the same value

        }
      }
    }
  ]
}
```

     * adding {@code entry} to relevant eviction lists.
     *
     * <p>Note: this method should only be called under lock, as it directly manipulates the
     * eviction queues. Unlocked reads should use {@link #recordRead}.
     */
    @GuardedBy("this")
    void recordLockedRead(ReferenceEntry<K, V> entry, long now) {
      if (map.recordsAccess()) {
        entry.setAccessTime(now);

TF_CAPI_EXPORT extern TF_Library* TF_LoadPluggableDeviceLibrary(
    const char* library_filename, TF_Status* status);

// Frees the memory associated with the library handle.
// Does NOT unload the library.
TF_CAPI_EXPORT extern void TF_DeletePluggableDeviceLibraryHandle(
    TF_Library* lib_handle);

// Removes `func_name` from `g`. If `func_name` is not in `g`, an error will be
// returned.

 * from its source file.
 */
public class SynonymFile extends DictionaryFile<SynonymItem> {
    private static final String SYNONYM = "synonym";

    /** The list of synonym items loaded from the dictionary file. */
    List<SynonymItem> synonymItemList;

    /**
     * Constructs a new synonym file.
     *
     * @param id        The unique identifier for this dictionary file.

    }

    /**
     * Registers this API manager.
     */
    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {
            logger.info("Loaded {}", this.getClass().getSimpleName());
        }
        ComponentUtil.getWebApiManagerFactory().add(this);
    }

    @Override
    protected FormatType detectFormatType(final HttpServletRequest request) {

     * use by the jCIFS library. The Properties must be set <i>before jCIFS
     * classes are accessed</i> as most jCIFS classes load properties statically once.
     * Using this method will also override properties loaded
     * using the <code>-Djcifs.properties=</code> commandline parameter.
     */

    /**
     * Set the properties to be used for configuration.
     *
     * @param prp the properties to set
     */