org.caffinitas.ohc

Interface OHCache<K,V>

All Superinterfaces:

AutoCloseable, Closeable

All Known Implementing Classes:

OHCacheImpl, OHCacheImpl

public interface OHCache<K,V>
extends Closeable

Method Summary

Modifier and Type	Method and Description
boolean	addOrReplace(K key, V old, V value) Same as 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()
boolean	containsKey(K key)
int	deserializeEntries(ReadableByteChannel channel)
boolean	deserializeEntry(ReadableByteChannel channel)
CloseableIterator<K>	deserializeKeys(ReadableByteChannel channel)
long	freeCapacity()
V	get(K key)
EstimatedHistogram	getBucketHistogram()
DirectValueAccess	getDirect(K key) Returns a closeable byte buffer.
DirectValueAccess	getDirect(K key, boolean updateLRU) Like getDirect(Object), but allows skipping the update of LRU stats when updateLRU is false.
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)
Future<V>	getWithLoaderAsync(K key, CacheLoader<K,V> loader, long expireAt)
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()
void	put(K key, V value) Same as put(Object, Object, long) but uses the configured default TTL, if any.
void	put(K key, V value, long expireAt) Adds the key/value.
void	putAll(Map<? extends K,? extends V> m)
boolean	putIfAbsent(K k, V v) Same as 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.
void	remove(K key)
void	removeAll(Iterable<K> 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()

Methods inherited from interface java.io.Closeable

close

Method Detail

put

void put(K key,
         V value)

Same as put(Object, Object, long) but uses the configured default TTL, if any.

put

void put(K key,
         V value,
         long expireAt)

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.

addOrReplace

boolean addOrReplace(K key,
                     V old,
                     V value)

Same as addOrReplace(Object, Object, Object, long) but uses the configured default TTL, if any.

addOrReplace

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. If the entry size of key/value exceeds the configured maximum entry length, the old value is removed.

putIfAbsent

boolean putIfAbsent(K k,
                    V v)

Same as putIfAbsent(Object, Object, long) but uses the configured default TTL, if any.

putIfAbsent

boolean putIfAbsent(K key,
                    V value,
                    long expireAt)

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.

putAll

void putAll(Map<? extends K,? extends V> m)

remove

void remove(K key)

removeAll

void removeAll(Iterable<K> keys)

clear

void clear()

get

V get(K key)

containsKey

boolean containsKey(K key)

getDirect

DirectValueAccess getDirect(K key)

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().

Returns:

reference-counted byte buffer or null if key does not exist.

getDirect

DirectValueAccess getDirect(K key,
                            boolean updateLRU)

Like getDirect(Object), but allows skipping the update of LRU stats when updateLRU is false.

Returns:

reference-counted byte buffer or null if key does not exist.

getWithLoaderAsync

Future<V> getWithLoaderAsync(K key,
                             CacheLoader<K,V> loader)

getWithLoaderAsync

Future<V> getWithLoaderAsync(K key,
                             CacheLoader<K,V> loader,
                             long expireAt)

getWithLoader

V getWithLoader(K key,
                CacheLoader<K,V> loader)
         throws InterruptedException,
                ExecutionException

Throws:

InterruptedException

ExecutionException

getWithLoader

V getWithLoader(K key,
                CacheLoader<K,V> loader,
                long timeout,
                TimeUnit unit)
         throws InterruptedException,
                ExecutionException,
                TimeoutException

Throws:

InterruptedException

ExecutionException

TimeoutException

hotKeyIterator

CloseableIterator<K> hotKeyIterator(int n)

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.

keyIterator

CloseableIterator<K> keyIterator()

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.

hotKeyBufferIterator

CloseableIterator<ByteBuffer> hotKeyBufferIterator(int n)

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.

keyBufferIterator

CloseableIterator<ByteBuffer> keyBufferIterator()

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.

deserializeEntry

boolean deserializeEntry(ReadableByteChannel channel)
                  throws IOException

Throws:

IOException

serializeEntry

boolean serializeEntry(K key,
                       WritableByteChannel channel)
                throws IOException

Throws:

IOException

deserializeEntries

int deserializeEntries(ReadableByteChannel channel)
                throws IOException

Throws:

IOException

serializeHotNEntries

int serializeHotNEntries(int n,
                         WritableByteChannel channel)
                  throws IOException

Throws:

IOException

serializeHotNKeys

int serializeHotNKeys(int n,
                      WritableByteChannel channel)
               throws IOException

Throws:

IOException

deserializeKeys

CloseableIterator<K> deserializeKeys(ReadableByteChannel channel)
                              throws IOException

Throws:

IOException

resetStatistics

void resetStatistics()

size

long size()

hashTableSizes

int[] hashTableSizes()

perSegmentSizes

long[] perSegmentSizes()

getBucketHistogram

EstimatedHistogram getBucketHistogram()

segments

int segments()

capacity

long capacity()

memUsed

long memUsed()

freeCapacity

long freeCapacity()

loadFactor

float loadFactor()

stats

OHCacheStats stats()

setCapacity

void setCapacity(long capacity)

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.