## org.apache.lucene.facet.taxonomy.writercache.lru
Class LruTaxonomyWriterCache

    java.lang.Object
      org.apache.lucene.facet.taxonomy.writercache.lru.LruTaxonomyWriterCache

All Implemented Interfaces:
  TaxonomyWriterCache

    public class LruTaxonomyWriterCache

extends Object
implements TaxonomyWriterCache

LRU `TaxonomyWriterCache` - good choice for huge taxonomies.

WARNING: This API is experimental and might change in incompatible ways in the next release.

Nested Class Summary
`static class` `LruTaxonomyWriterCache.LRUType` Determines cache type.

Constructor Summary
`LruTaxonomyWriterCache(int cacheSize)`
`LruTaxonomyWriterCache(int cacheSize, LruTaxonomyWriterCache.LRUType lruType)`

Method Summary
`void` `clear()` Clears the content of the cache.
`void` `close()` Let go of whatever resources the cache is holding.
`int` `get(CategoryPath categoryPath)` Lookup a category in the cache, returning its ordinal, or a negative number if the category is not in the cache.
`boolean` `isFull()` Returns true if the cache is full, such that the next `TaxonomyWriterCache.put(org.apache.lucene.facet.taxonomy.CategoryPath, int)` will evict entries from it, false otherwise.
`boolean` `put(CategoryPath categoryPath, int ordinal)` Add a category to the cache, with the given ordinal as the value.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### LruTaxonomyWriterCache

    public LruTaxonomyWriterCache(int cacheSize)

### LruTaxonomyWriterCache

    public LruTaxonomyWriterCache(int cacheSize,
                                  LruTaxonomyWriterCache.LRUType lruType)

Method Detail

### isFull

    public boolean isFull()

  Description copied from interface: `TaxonomyWriterCache`
  Returns true if the cache is full, such that the next `TaxonomyWriterCache.put(org.apache.lucene.facet.taxonomy.CategoryPath, int)` will evict entries from it, false otherwise.

  Specified by:
    `isFull` in interface `TaxonomyWriterCache`

### clear

    public void clear()

  Description copied from interface: `TaxonomyWriterCache`
  Clears the content of the cache. Unlike `TaxonomyWriterCache.close()`, the caller can assume that the cache is still operable after this method returns.

  Specified by:
    `clear` in interface `TaxonomyWriterCache`

### close

    public void close()

  Description copied from interface: `TaxonomyWriterCache`
  Let go of whatever resources the cache is holding. After a close(), this object can no longer be used.

  Specified by:
    `close` in interface `TaxonomyWriterCache`

### get

    public int get(CategoryPath categoryPath)

  Description copied from interface: `TaxonomyWriterCache`
  Lookup a category in the cache, returning its ordinal, or a negative number if the category is not in the cache.

  It is up to the caller to remember what a negative response means: If the caller knows the cache is complete (it was initially fed with all the categories, and since then put() never returned true) it means the category does not exist. Otherwise, the category might still exist, but just be missing from the cache.

  Specified by:
    `get` in interface `TaxonomyWriterCache`

### put

    public boolean put(CategoryPath categoryPath,
                       int ordinal)

  Description copied from interface: `TaxonomyWriterCache`
  Add a category to the cache, with the given ordinal as the value.

  If the implementation keeps only a partial cache (e.g., an LRU cache) and finds that its cache is full, it should clear up part of the cache and return `true`. Otherwise, it should return `false`.

  The reason why the caller needs to know if part of the cache was cleared is that in that case it will have to commit its on-disk index (so that all the latest category additions can be searched on disk, if we can't rely on the cache to contain them).

  Ordinals should be non-negative. Currently there is no defined way to specify that a cache should remember a category does NOT exist. It doesn't really matter, because normally the next thing we do after finding that a category does not exist is to add it.

  Specified by:
    `put` in interface `TaxonomyWriterCache`

Copyright © 2000-2013 Apache Software Foundation. All Rights Reserved.