OHCacheImpl (Off-Heap Cache)

java.lang.Object
- org.caffinitas.ohc.tables.OHCacheImpl<K,V>

All Implemented Interfaces:: Closeable, AutoCloseable, OHCache<K,V>

public final class OHCacheImpl<K,V>
extends Object
implements OHCache<K,V>

Constructor Summary

Constructors
Constructor and Description

OHCacheImpl(OHCacheBuilder<K,V> builder)

Constructors
Constructor and Description
`OHCacheImpl(OHCacheBuilder<K,V> builder)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addOrReplace(K key, V old, V value)` Adds key/value if either the key is not present or the existing value matches parameter `old`.
`long`	`capacity()`
`void`	`clear()`
`void`	`close()`
`boolean`	`containsKey(K key)`
`int`	`deserializeEntries(ReadableByteChannel channel)`
`boolean`	`deserializeEntry(ReadableByteChannel channel)`
`CloseableIterator<K>`	`deserializeKeys(ReadableByteChannel channel)`
`long`	`evictedEntries()`
`long`	`freeCapacity()`
`V`	`get(K key)`
`EstimatedHistogram`	`getBucketHistogram()`
`V`	`getWithLoader(K key, CacheLoader<K,V> loader)`
`V`	`getWithLoader(K key, CacheLoader<K,V> loader, long timeout, TimeUnit unit)`
`Future<V>`	`getWithLoaderAsync(K key, CacheLoader<K,V> loader)`
`int[]`	`hashTableSizes()`
`CloseableIterator<ByteBuffer>`	`hotKeyBufferIterator(int n)` Builds an iterator over all keys returning direct byte buffers.
`CloseableIterator<K>`	`hotKeyIterator(int n)` Builds an iterator over the N most recently used keys returning deserialized objects.
`CloseableIterator<ByteBuffer>`	`keyBufferIterator()` Builds an iterator over all keys returning direct byte buffers.
`CloseableIterator<K>`	`keyIterator()` Builds an iterator over all keys returning deserialized objects.
`float`	`loadFactor()`
`long`	`lruCompactions()`
`long`	`memUsed()`
`long[]`	`perSegmentSizes()`
`void`	`put(K k, V v)` Adds the key/value.
`void`	`putAll(Map<? extends K,? extends V> m)`
`boolean`	`putIfAbsent(K k, V v)` Adds the key/value if the key is not present.
`void`	`remove(K k)`
`void`	`removeAll(Iterable<K> iterable)`
`void`	`resetStatistics()`
`int`	`segments()`
`boolean`	`serializeEntry(K key, WritableByteChannel channel)`
`int`	`serializeHotNEntries(int n, WritableByteChannel channel)`
`int`	`serializeHotNKeys(int n, WritableByteChannel channel)`
`void`	`setCapacity(long capacity)` Modify the cache's capacity.
`long`	`size()`
`OHCacheStats`	`stats()`

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

- Constructor Detail
  - OHCacheImpl
```
public OHCacheImpl(OHCacheBuilder<K,V> builder)
```
- Method Detail
  - get
```
public V get(K key)
```
    Specified by:
    
    get in interface OHCache<K,V>
  - containsKey
```
public boolean containsKey(K key)
```
    Specified by:
    
    containsKey in interface OHCache<K,V>
  - put
```
public void put(K k,
                V v)
```
    Description copied from interface: OHCache
    
    Adds the key/value. If the entry size of key/value exceeds the configured maximum entry length, any previously existing entry for the key is removed.
    
    Specified by:
    
    put in interface OHCache<K,V>
  - addOrReplace
```
public boolean addOrReplace(K key,
                            V old,
                            V value)
```
    Description copied from interface: OHCache
    
    Adds key/value if either the key is not present or the existing value matches parameter old. If the entry size of key/value exceeds the configured maximum entry length, the old value is removed.
    
    Specified by:
    
    addOrReplace in interface OHCache<K,V>
  - putIfAbsent
```
public boolean putIfAbsent(K k,
                           V v)
```
    Description copied from interface: OHCache
    
    Adds the key/value if the key is not present. If the entry size of key/value exceeds the configured maximum entry length, any previously existing entry for the key is removed.
    
    Specified by:
    
    putIfAbsent in interface OHCache<K,V>
  - remove
```
public void remove(K k)
```
    Specified by:
    
    remove in interface OHCache<K,V>
  - getWithLoader
```
public V getWithLoader(K key,
                       CacheLoader<K,V> loader)
                throws InterruptedException,
                       ExecutionException
```
    Specified by:
    
    getWithLoader in interface OHCache<K,V>
    
    Throws:
    
    InterruptedException
    
    ExecutionException
  - getWithLoader
```
public V getWithLoader(K key,
                       CacheLoader<K,V> loader,
                       long timeout,
                       TimeUnit unit)
                throws InterruptedException,
                       ExecutionException,
                       TimeoutException
```
    Specified by:
    
    getWithLoader in interface OHCache<K,V>
    
    Throws:
    
    InterruptedException
    
    ExecutionException
    
    TimeoutException
  - getWithLoaderAsync
```
public Future<V> getWithLoaderAsync(K key,
                                    CacheLoader<K,V> loader)
```
    Specified by:
    
    getWithLoaderAsync in interface OHCache<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface OHCache<K,V>
  - setCapacity
```
public void setCapacity(long capacity)
```
    Description copied from interface: OHCache
    
    Modify the cache's capacity. Lowering the capacity will not immediately remove any entry nor will it immediately free allocated (off heap) memory.
    Future operations will even allocate in flight, temporary memory - i.e. setting capacity to 0 does not disable the cache, it will continue to work but cannot add more data.
    
    Specified by:
    
    setCapacity in interface OHCache<K,V>
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - resetStatistics
```
public void resetStatistics()
```
    Specified by:
    
    resetStatistics in interface OHCache<K,V>
  - stats
```
public OHCacheStats stats()
```
    Specified by:
    
    stats in interface OHCache<K,V>
  - capacity
```
public long capacity()
```
    Specified by:
    
    capacity in interface OHCache<K,V>
  - freeCapacity
```
public long freeCapacity()
```
    Specified by:
    
    freeCapacity in interface OHCache<K,V>
  - evictedEntries
```
public long evictedEntries()
```
  - size
```
public long size()
```
    Specified by:
    
    size in interface OHCache<K,V>
  - lruCompactions
```
public long lruCompactions()
```
  - segments
```
public int segments()
```
    Specified by:
    
    segments in interface OHCache<K,V>
  - loadFactor
```
public float loadFactor()
```
    Specified by:
    
    loadFactor in interface OHCache<K,V>
  - hashTableSizes
```
public int[] hashTableSizes()
```
    Specified by:
    
    hashTableSizes in interface OHCache<K,V>
  - perSegmentSizes
```
public long[] perSegmentSizes()
```
    Specified by:
    
    perSegmentSizes in interface OHCache<K,V>
  - getBucketHistogram
```
public EstimatedHistogram getBucketHistogram()
```
    Specified by:
    
    getBucketHistogram in interface OHCache<K,V>
  - deserializeKeys
```
public CloseableIterator<K> deserializeKeys(ReadableByteChannel channel)
                                     throws IOException
```
    Specified by:
    
    deserializeKeys in interface OHCache<K,V>
    
    Throws:
    
    IOException
  - deserializeEntry
```
public boolean deserializeEntry(ReadableByteChannel channel)
                         throws IOException
```
    Specified by:
    
    deserializeEntry in interface OHCache<K,V>
    
    Throws:
    
    IOException
  - serializeEntry
```
public boolean serializeEntry(K key,
                              WritableByteChannel channel)
                       throws IOException
```
    Specified by:
    
    serializeEntry in interface OHCache<K,V>
    
    Throws:
    
    IOException
  - deserializeEntries
```
public int deserializeEntries(ReadableByteChannel channel)
                       throws IOException
```
    Specified by:
    
    deserializeEntries in interface OHCache<K,V>
    
    Throws:
    
    IOException
  - serializeHotNEntries
```
public int serializeHotNEntries(int n,
                                WritableByteChannel channel)
                         throws IOException
```
    Specified by:
    
    serializeHotNEntries in interface OHCache<K,V>
    
    Throws:
    
    IOException
  - serializeHotNKeys
```
public int serializeHotNKeys(int n,
                             WritableByteChannel channel)
                      throws IOException
```
    Specified by:
    
    serializeHotNKeys in interface OHCache<K,V>
    
    Throws:
    
    IOException
  - putAll
```
public void putAll(Map<? extends K,? extends V> m)
```
    Specified by:
    
    putAll in interface OHCache<K,V>
  - removeAll
```
public void removeAll(Iterable<K> iterable)
```
    Specified by:
    
    removeAll in interface OHCache<K,V>
  - memUsed
```
public long memUsed()
```
    Specified by:
    
    memUsed in interface OHCache<K,V>
  - hotKeyIterator
```
public CloseableIterator<K> hotKeyIterator(int n)
```
    Description copied from interface: OHCache
    
    Builds an iterator over the N most recently used keys returning deserialized objects. You must call close() on the returned iterator.
    Note: During a rehash, the implementation might return keys twice or not at all.
    
    Specified by:
    
    hotKeyIterator in interface OHCache<K,V>
  - hotKeyBufferIterator
```
public CloseableIterator<ByteBuffer> hotKeyBufferIterator(int n)
```
    Description copied from interface: OHCache
    
    Builds an iterator over all keys returning direct byte buffers. Do not use a returned ByteBuffer after calling any method on the iterator. You must call close() on the returned iterator.
    Note: During a rehash, the implementation might return keys twice or not at all.
    
    Specified by:
    
    hotKeyBufferIterator in interface OHCache<K,V>
  - keyIterator
```
public CloseableIterator<K> keyIterator()
```
    Description copied from interface: OHCache
    
    Builds an iterator over all keys returning deserialized objects. You must call close() on the returned iterator.
    Note: During a rehash, the implementation might return keys twice or not at all.
    
    Specified by:
    
    keyIterator in interface OHCache<K,V>
  - keyBufferIterator
```
public CloseableIterator<ByteBuffer> keyBufferIterator()
```
    Description copied from interface: OHCache
    
    Builds an iterator over all keys returning direct byte buffers. Do not use a returned ByteBuffer after calling any method on the iterator. You must call close() on the returned iterator.
    Note: During a rehash, the implementation might return keys twice or not at all.
    
    Specified by:
    
    keyBufferIterator in interface OHCache<K,V>

Class OHCacheImpl<K,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

OHCacheImpl

Method Detail

get

containsKey

put

addOrReplace

putIfAbsent

remove

getWithLoader

getWithLoader

getWithLoaderAsync

clear

setCapacity

close

resetStatistics

stats

capacity

freeCapacity

evictedEntries

size

lruCompactions

segments

loadFactor

hashTableSizes

perSegmentSizes

getBucketHistogram

deserializeKeys

deserializeEntry

serializeEntry

deserializeEntries

serializeHotNEntries

serializeHotNKeys

putAll

removeAll

memUsed

hotKeyIterator

hotKeyBufferIterator

keyIterator

keyBufferIterator