OHCacheChunkedImpl (OHC parent 0.6.1 API)

java.lang.Object
- org.caffinitas.ohc.chunked.OHCacheChunkedImpl<K,V>

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

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

Field Summary
- Fields inherited from interface org.caffinitas.ohc.OHCache
  NEVER_EXPIRE, USE_DEFAULT_EXPIRE_AT

Constructor Summary

Constructors
Constructor and Description

OHCacheChunkedImpl(OHCacheBuilder<K,V> builder)

Constructors
Constructor and Description
`OHCacheChunkedImpl(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)` Same as `OHCache.addOrReplace(Object, Object, Object, long)` but uses the configured default TTL, if any.
`boolean`	`addOrReplace(K key, V old, V value, long expireAt)` Adds key/value if either the key is not present or the existing value matches parameter `old`.
`long`	`capacity()`
`void`	`clear()` Removes all entries from the cache.
`void`	`close()`
`boolean`	`containsKey(K key)` Checks whether an entry for a given key exists.
`int`	`deserializeEntries(ReadableByteChannel channel)`
`boolean`	`deserializeEntry(ReadableByteChannel channel)`
`CloseableIterator<K>`	`deserializeKeys(ReadableByteChannel channel)`
`long`	`freeCapacity()`
`V`	`get(K key)` Get the value for a given key.
`EstimatedHistogram`	`getBucketHistogram()`
`DirectValueAccess`	`getDirect(K key)` Returns a closeable byte buffer.
`DirectValueAccess`	`getDirect(K key, boolean updateLRU)` Like `OHCache.getDirect(Object)`, but allows skipping the update of LRU stats when `updateLRU` is `false`.
`V`	`getWithLoader(K key, CacheLoader<K,V> loader)` Effectively calls `getWithLoaderAsync(key, loader).get()`.
`V`	`getWithLoader(K key, CacheLoader<K,V> loader, long timeout, TimeUnit unit)` Effectively calls `getWithLoaderAsync(key, loader).get(timeout, unit)`.
`Future<V>`	`getWithLoaderAsync(K key, CacheLoader<K,V> loader)` Shortcut to call `OHCache.getWithLoader(Object, CacheLoader, long, TimeUnit)` using the default entry time-to-live.
`Future<V>`	`getWithLoaderAsync(K key, CacheLoader<K,V> loader, long expireAt)` Shortcut to call `OHCache.getWithLoader(Object, CacheLoader, long, TimeUnit)` using the default entry time-to-live.
`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`	`memUsed()`
`long[]`	`perSegmentSizes()`
`boolean`	`put(K key, V value)` Same as `OHCache.put(Object, Object, long)` but uses the configured default TTL, if any.
`boolean`	`put(K key, V value, long expireAt)` Adds the key/value.
`void`	`putAll(Map<? extends K,? extends V> m)` This is effectively a shortcut to add all entries in the given map `m`.
`boolean`	`putIfAbsent(K key, V value)` Same as `OHCache.putIfAbsent(Object, Object, long)` but uses the configured default TTL, if any.
`boolean`	`putIfAbsent(K key, V value, long expireAt)` Adds the key/value if the key is not present.
`boolean`	`remove(K k)` Remove a single entry for the given key.
`void`	`removeAll(Iterable<K> iterable)` This is effectively a shortcut to remove the entries for all keys given in the iterable `keys`.
`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()`
`String`	`toString()`

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

- Constructor Detail
  - OHCacheChunkedImpl
```
public OHCacheChunkedImpl(OHCacheBuilder<K,V> builder)
```
- Method Detail
  - getDirect
```
public DirectValueAccess getDirect(K key)
```
    Description copied from interface: OHCache
    
    Returns a closeable byte buffer. You must close the returned DirectValueAccess instance after use. After closing, you must not call any of the methods of the ByteBuffer returned by DirectValueAccess.buffer().
    
    Specified by:
    
    getDirect in interface OHCache<K,V>
    
    Returns:
    
    reference-counted byte buffer or null if key does not exist.
  - getDirect
```
public DirectValueAccess getDirect(K key,
                                   boolean updateLRU)
```
    Description copied from interface: OHCache
    
    Like OHCache.getDirect(Object), but allows skipping the update of LRU stats when updateLRU is false.
    
    Specified by:
    
    getDirect in interface OHCache<K,V>
    
    Returns:
    
    reference-counted byte buffer or null if key does not exist.
  - get
```
public V get(K key)
```
    Description copied from interface: OHCache
    
    Get the value for a given key.
    
    Specified by:
    
    get in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the entry to be retrieved. Must not be null.
    
    Returns:
    
    either the non-null value or null if no entry for the requested key exists
  - containsKey
```
public boolean containsKey(K key)
```
    Description copied from interface: OHCache
    
    Checks whether an entry for a given key exists. Usually, this is more efficient than testing for null via OHCache.get(Object).
    
    Specified by:
    
    containsKey in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the entry to be retrieved. Must not be null.
    
    Returns:
    
    either true if an entry for the given key exists or false if no entry for the requested key exists
  - put
```
public boolean put(K key,
                   V value)
```
    Description copied from interface: OHCache
    
    Same as OHCache.put(Object, Object, long) but uses the configured default TTL, if any.
    
    Specified by:
    
    put in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the entry to be added. Must not be null.
    
    value - value of the entry to be added. Must not be null.
    
    Returns:
    
    true, if the entry has been added, false otherwise
  - put
```
public boolean put(K key,
                   V value,
                   long expireAt)
```
    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>
    
    Parameters:
    
    key - key of the entry to be added. Must not be null.
    
    value - value of the entry to be added. Must not be null.
    
    expireAt - timestamp in milliseconds since "epoch" (like System.currentTimeMillis()) when the entry shall expire. Pass OHCache.USE_DEFAULT_EXPIRE_AT for the configured default time-to-live or OHCache.NEVER_EXPIRE to let it never expire.
    
    Returns:
    
    true, if the entry has been added, false otherwise
  - addOrReplace
```
public boolean addOrReplace(K key,
                            V old,
                            V value)
```
    Description copied from interface: OHCache
    
    Same as OHCache.addOrReplace(Object, Object, Object, long) but uses the configured default TTL, if any.
    
    Specified by:
    
    addOrReplace in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the entry to be added or replaced. Must not be null.
    
    old - if the entry exists, it's serialized value is compared to the serialized value of old and only replaced, if it matches.
    
    value - value of the entry to be added. Must not be null.
    
    Returns:
    
    true on success or false if the existing value does not matcuh old
  - addOrReplace
```
public boolean addOrReplace(K key,
                            V old,
                            V value,
                            long expireAt)
```
    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>
    
    Parameters:
    
    key - key of the entry to be added or replaced. Must not be null.
    
    old - if the entry exists, it's serialized value is compared to the serialized value of old and only replaced, if it matches.
    
    value - value of the entry to be added. Must not be null.
    
    expireAt - timestamp in milliseconds since "epoch" (like System.currentTimeMillis()) when the entry shall expire. Pass OHCache.USE_DEFAULT_EXPIRE_AT for the configured default time-to-live or OHCache.NEVER_EXPIRE to let it never expire.
    
    Returns:
    
    true on success or false if the existing value does not matcuh old
  - putIfAbsent
```
public boolean putIfAbsent(K key,
                           V value)
```
    Description copied from interface: OHCache
    
    Same as OHCache.putIfAbsent(Object, Object, long) but uses the configured default TTL, if any.
    
    Specified by:
    
    putIfAbsent in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the entry to be added. Must not be null.
    
    value - value of the entry to be added. Must not be null.
    
    Returns:
    
    true on success or false if the key is already present.
  - putIfAbsent
```
public boolean putIfAbsent(K key,
                           V value,
                           long expireAt)
```
    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>
    
    Parameters:
    
    key - key of the entry to be added. Must not be null.
    
    value - value of the entry to be added. Must not be null.
    
    expireAt - timestamp in milliseconds since "epoch" (like System.currentTimeMillis()) when the entry shall expire. Pass OHCache.USE_DEFAULT_EXPIRE_AT for the configured default time-to-live or OHCache.NEVER_EXPIRE to let it never expire.
    
    Returns:
    
    true on success or false if the key is already present.
  - remove
```
public boolean remove(K k)
```
    Description copied from interface: OHCache
    
    Remove a single entry for the given key.
    
    Specified by:
    
    remove in interface OHCache<K,V>
    
    Parameters:
    
    k - key of the entry to be removed. Must not be null.
    
    Returns:
    
    true, if the entry has been removed, false otherwise
  - getWithLoader
```
public V getWithLoader(K key,
                       CacheLoader<K,V> loader)
                throws InterruptedException,
                       ExecutionException
```
    Description copied from interface: OHCache
    
    Effectively calls getWithLoaderAsync(key, loader).get().
    
    Specified by:
    
    getWithLoader in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the value to load
    
    loader - loader implementation to use
    
    Returns:
    
    the loaded value or null
    
    Throws:
    
    InterruptedException - as from the contract of Future.get()
    
    ExecutionException - thrown if the CacheLoader.load(Object) implementation threw an error or a runtime exception occured due to not enough memory for example.
  - getWithLoader
```
public V getWithLoader(K key,
                       CacheLoader<K,V> loader,
                       long timeout,
                       TimeUnit unit)
                throws InterruptedException,
                       ExecutionException,
                       TimeoutException
```
    Description copied from interface: OHCache
    
    Effectively calls getWithLoaderAsync(key, loader).get(timeout, unit).
    
    Specified by:
    
    getWithLoader in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the value to load
    
    loader - loader implementation to use
    
    timeout - timeout value to be passed to Future.get(long, TimeUnit)
    
    unit - timeout unit to be passed to Future.get(long, TimeUnit)
    
    Returns:
    
    the loaded value or null
    
    Throws:
    
    InterruptedException - as from the contract of Future.get()
    
    ExecutionException - thrown if the CacheLoader.load(Object) implementation threw an error or a runtime exception occured due to not enough memory for example.
    
    TimeoutException - as from the contract of Future.get(long, TimeUnit)
  - getWithLoaderAsync
```
public Future<V> getWithLoaderAsync(K key,
                                    CacheLoader<K,V> loader)
```
    Description copied from interface: OHCache
    
    Shortcut to call OHCache.getWithLoader(Object, CacheLoader, long, TimeUnit) using the default entry time-to-live. Note that the cache has to be configured with an Executor to schedule the load process.
    Note that the future may indicate a failure via it's get methods if the CacheLoader.load(Object) implementation threw an error or a runtime exception occured due to not enough memory for example.
    
    Specified by:
    
    getWithLoaderAsync in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the value to load
    
    loader - loader implementation to use
    
    Returns:
    
    a future to process the load request asynchronously.
  - getWithLoaderAsync
```
public Future<V> getWithLoaderAsync(K key,
                                    CacheLoader<K,V> loader,
                                    long expireAt)
```
    Description copied from interface: OHCache
    
    Shortcut to call OHCache.getWithLoader(Object, CacheLoader, long, TimeUnit) using the default entry time-to-live. Note that the cache has to be configured with an Executor to schedule the load process.
    Note that the future may indicate a failure via it's get methods if the CacheLoader.load(Object) implementation threw an error or a runtime exception occured due to not enough memory for example.
    
    Specified by:
    
    getWithLoaderAsync in interface OHCache<K,V>
    
    Parameters:
    
    key - key of the value to load
    
    loader - loader implementation to use
    
    Returns:
    
    a future to process the load request asynchronously.
  - clear
```
public void clear()
```
    Description copied from interface: OHCache
    
    Removes all entries from the cache.
    
    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>
  - size
```
public long size()
```
    Specified by:
    
    size in interface OHCache<K,V>
  - 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)
```
    Description copied from interface: OHCache
    
    This is effectively a shortcut to add all entries in the given map m.
    
    Specified by:
    
    putAll in interface OHCache<K,V>
    
    Parameters:
    
    m - entries to be added
  - removeAll
```
public void removeAll(Iterable<K> iterable)
```
    Description copied from interface: OHCache
    
    This is effectively a shortcut to remove the entries for all keys given in the iterable keys.
    
    Specified by:
    
    removeAll in interface OHCache<K,V>
    
    Parameters:
    
    iterable - keys to be removed
  - 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>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class OHCacheChunkedImpl<K,V>

Field Summary

Fields inherited from interface org.caffinitas.ohc.OHCache

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

OHCacheChunkedImpl

Method Detail

getDirect

getDirect

get

containsKey

put

put

addOrReplace

addOrReplace

putIfAbsent

putIfAbsent

remove

getWithLoader

getWithLoader

getWithLoaderAsync

getWithLoaderAsync

clear

setCapacity

close

resetStatistics

stats

capacity

freeCapacity

size

segments

loadFactor

hashTableSizes

perSegmentSizes

getBucketHistogram

deserializeKeys

deserializeEntry

serializeEntry

deserializeEntries

serializeHotNEntries

serializeHotNKeys

putAll

removeAll

memUsed

hotKeyIterator

hotKeyBufferIterator

keyIterator

keyBufferIterator

toString