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) 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()
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	memUsed()
long[]	perSegmentSizes()
void	put(K key, V value) 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 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)

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)

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)

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)

getWithLoaderAsync

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

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.