SieveCache

<K : Any, V : Any> SieveCache(
    maxSize: @IntRange(from = 1, to = 2147483646) Int,
    initialCapacity: @IntRange(from = 0, to = 2147483646) Int = DefaultScatterCapacity,
    sizeOf: (key, value) -> Int = { _, _ -> 1 },
    createValueFromKey: (key) -> V? = { null },
    onEntryRemoved: (key, oldValue, newValue?, evicted: Boolean) -> Unit = { _, _, _, _ ->
        }
)

Creates a new SieveCache.

inline fun all(predicate: (K, V) -> Boolean): Boolean

Returns true if all entries match the given predicate.

fun any(): Boolean

Returns true if this cache has at least one entry.

inline fun any(predicate: (K, V) -> Boolean): Boolean

Returns true if at least one entry matches the given predicate.

operator fun contains(key: K): Boolean

Returns true if the specified key is present in this cache, false otherwise.

fun containsKey(key: K): Boolean

Returns true if the specified key is present in this cache, false otherwise.

fun containsValue(value: V): Boolean

Returns true if the specified value is present in this hash map, false otherwise.

fun count(): Int

Returns the number of entries in this cache.

inline fun count(predicate: (K, V) -> Boolean): Int

Returns the number of entries matching the given predicate.

open operator fun equals(other: Any?): Boolean

Compares the specified object other with this cache for equality. The two objects are considered equal if other:

• Is a SieveCache

• Has the same size and count as this cache

• Contains key/value pairs equal to this cache's pair

fun evictAll(): Unit

Removes all the entries from this cache. Upon each removal, onEntryRemoved is invoked with the evicted parameter set to true.

inline fun forEach(block: (key, value) -> Unit): Unit

Iterates over every key/value pair stored in this cache by invoking the specified block lambda. The iteration order is not specified.

NOTE: Iterating over the content of the cache does not mark entries as recently visited, and therefore does not affect which entries get evicted first.

inline fun forEachKey(block: (key) -> Unit): Unit

Iterates over every key stored in this cache by invoking the specified block lambda.

NOTE: Iterating over the content of the cache does not mark entries as recently visited, and therefore does not affect which entries get evicted first.

inline fun forEachValue(block: (value) -> Unit): Unit

Iterates over every value stored in this cache by invoking the specified block lambda.

NOTE: Iterating over the content of the cache does not mark entries as recently visited, and therefore does not affect which entries get evicted first.

operator fun get(key: K): V?

Returns the value for key if it exists in the cache or can be created by createValueFromKey. Return null if a value is not present in the cache and cannot be created.

open fun hashCode(): Int

Returns the hash code value for this cache. The hash code the sum of the hash codes of each key/value pair.

fun isEmpty(): Boolean

Indicates whether this cache is empty.

fun isNotEmpty(): Boolean

Returns true if this cache is not empty.

inline operator fun minusAssign(key: K): Unit

Removes the specified key and its associated value from the map.

inline operator fun minusAssign(keys: Array<K>): Unit

Removes the specified keys and their associated value from the map.

inline operator fun minusAssign(keys: Iterable<K>): Unit

Removes the specified keys and their associated value from the map.

inline operator fun minusAssign(keys: ObjectList<K>): Unit

Removes the specified keys and their associated value from the map.

inline operator fun minusAssign(keys: ScatterSet<K>): Unit

Removes the specified keys and their associated value from the map.

inline operator fun minusAssign(keys: Sequence<K>): Unit

Removes the specified keys and their associated value from the map.

fun none(): Boolean

Returns true if this cache has no entries.

inline operator fun plusAssign(from: Map<K, V>): Unit

Puts all the key/value mappings in the from map into this map. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

inline operator fun plusAssign(from: ScatterMap<K, V>): Unit

Puts all the key/value mappings in the from map into this map. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

inline operator fun plusAssign(from: SieveCache<K, V>): Unit

Puts all the key/value mappings in the from map into this map. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

inline operator fun plusAssign(pair: Pair<K, V>): Unit

Puts the key/value mapping from the pair in this cache, using the first element as the key, and the second element as the value. See put for more details about the insertion behavior.

inline operator fun plusAssign(pairs: Array<Pair<K, V>>): Unit

Puts all the pairs into this map, using the first component of the pair as the key, and the second component as the value. Calling this * method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

inline operator fun plusAssign(pairs: Iterable<Pair<K, V>>): Unit

Puts all the pairs into this map, using the first component of the pair as the key, and the second component as the value. Calling this * method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

inline operator fun plusAssign(pairs: Sequence<Pair<K, V>>): Unit

Puts all the pairs into this map, using the first component of the pair as the key, and the second component as the value. Calling this * method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

fun put(key: K, value: V): V?

Adds value to the cache using the specific key. If key is already present in the map, the association is modified and the previously associated value is replaced with value. If key is not present, a new entry is added to the map. If an existing value is replaced, onEntryRemoved will be invoked with the evicted parameter set to false.

When value is added to the cache, sizeOf is invoked to query its size. If the total size of the cache, including the new value's size, is greater than maxSize, existing entries will be evicted. On each removal due to an eviction, onEntryRemoved will be invoked with the evicted parameter set to true.

Return the previous value associated with the key, or null if the key was not present in the cache.

fun putAll(from: Map<K, V>): Unit

Puts all the key/value mappings in the from map into this cache. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

fun putAll(from: ScatterMap<K, V>): Unit

Puts all the key/value mappings in the from map into this cache. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

fun putAll(from: SieveCache<K, V>): Unit

Puts all the key/value mappings in the from cache into this cache. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

fun putAll(pairs: Array<Pair<K, V>>): Unit

Puts all the pairs into this cache, using the first component of the pair as the key, and the second component as the value. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

fun putAll(pairs: Iterable<Pair<K, V>>): Unit

Puts all the pairs into this cache, using the first component of the pair as the key, and the second component as the value. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

fun putAll(pairs: Sequence<Pair<K, V>>): Unit

Puts all the pairs into this cache, using the first component of the pair as the key, and the second component as the value. Calling this method is equivalent to calling put for each input pair. See put for more details about the behavior of each insertion.

fun remove(key: K): V?

Removes the specified key and its associated value from the cache. If the key was present in the cache, this function returns the value that was present before removal, otherwise it returns null. On successful removal, sizeOf will be invoked to query the size of the removed element, and onEntryRemoved will be invoked with the evicted parameter set to false.

fun remove(key: K, value: V): Boolean

Removes the specified key and its associated value from the cache if the associated value equals value. If the key was present in the cache, this function returns true, otherwise it returns false. On successful removal, sizeOf will be invoked to query the size of the removed element, and onEntryRemoved will be invoked with the evicted parameter set to false.

fun removeIf(predicate: (K, V) -> Boolean): Unit

Removes any mapping for which the specified predicate returns true.

fun resize(maxSize: @IntRange(from = 1, to = 2147483646) Int): Unit

Sets the maximum size of the cache to maxSize, in the unit defined by the implementation of sizeOf. The size must be strictly greater than 0. If the current total size of the entries in the cache is greater than the new maxSize, entries will be removed until the total size is less than or equal to maxSize. Upon each removal, onEntryRemoved is invoked with the evicted parameter set to true.

inline operator fun set(key: K, value: V): Unit

Adds value to the cache using the specific key. If key is already present in the cache, the association is modified and the previously associated value is replaced with value. If key is not present, a new entry is added to the map. If an existing value is replaced, onEntryRemoved will be invoked with the evicted parameter set to false.

When value is added to the cache, sizeOf is invoked to query its size. If the total size of the cache, including the new value's size, is greater than maxSize, existing entries will be evicted. On each removal due to an eviction, onEntryRemoved will be invoked with the evicted parameter set to true.

fun trimToSize(maxSize: Int): Unit

Remove entries until the total size of the remaining entries is less than or equal to maxSize. The size of the entries is defined by the implementation of sizeOf. Upon each removal, onEntryRemoved is invoked with the evicted parameter set to true.

If maxSize is set to -1 (or any negative value), all entries are removed.

val capacity: Int

Returns the number of entries that can be stored in this cache without requiring internal storage reallocation.

val count: Int

Returns the number of elements held in the cache.

val maxSize: Int

Return the maximum size of the cache before adding new elements causes existing elements to be evicted. The unit of maxSize is defined by the implementation of sizeOf. Using the default implementation of sizeOf, maxSize indicates the a maximum number of elements.

val size: Int

Size of the cache in the unit defined by the implementation of sizeOf (by default, the number of elements).