avail/avail.persistence.cache/Repository/LimitedCache

LimitedCache

class LimitedCache<K, V>(maximumSize: Int) : LinkedHashMap<K, V>

A Map which discards the oldest entry whenever an attempt is made to store more than the maximumSize elements in it.

Parameters

The keys of the cache.

The values associated with keys of the cache.

maximumSize

The maximum cache size.

Constructors

LimitedCache

fun LimitedCache(maximumSize: Int)

Construct a new LimitedCache with the given maximum size.

Functions

afterNodeAccess

open override fun afterNodeAccess(p0: HashMap.Node<K, V>)

afterNodeInsertion

open override fun afterNodeInsertion(p0: Boolean)

afterNodeRemoval

open override fun afterNodeRemoval(p0: HashMap.Node<K, V>)

capacity

fun capacity(): Int

clear

open override fun clear()

clone

open override fun clone(): Any

compute

open override fun compute(p0: K, p1: BiFunction<in K, in V?, out V?>): V?

computeIfAbsent

open override fun computeIfAbsent(p0: K, p1: Function<in K, out V>): V

computeIfPresent

open override fun computeIfPresent(p0: K, p1: BiFunction<in K, in V, out V?>): V?

containsKey

open override fun containsKey(key: K): Boolean

containsValue

open override fun containsValue(value: V): Boolean

equals

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

forEach

open override fun forEach(p0: BiConsumer<in K, in V>)

get

open operator override fun get(key: K): V?

getNode

fun getNode(p0: Any): HashMap.Node<K, V>

getOrDefault

open override fun getOrDefault(key: K, defaultValue: V): V

hashCode

open override fun hashCode(): Int

internalWriteEntries

open override fun internalWriteEntries(p0: ObjectOutputStream)

isEmpty

open override fun isEmpty(): Boolean

keysToArray

override fun <T : Any> keysToArray(p0: Array<T>): Array<T>

loadFactor

fun loadFactor(): Float

merge

open override fun merge( p0: K, p1: V, p2: BiFunction<in V, in V, out V?>): V?

newNode

open override fun newNode( p0: Int, p1: K, p2: V, p3: HashMap.Node<K, V>): HashMap.Node<K, V>

newTreeNode

open override fun newTreeNode( p0: Int, p1: K, p2: V, p3: HashMap.Node<K, V>): HashMap.TreeNode<K, V>

prepareArray

fun <T : Any> prepareArray(p0: Array<T>): Array<T>

put

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

putAll

open override fun putAll(from: Map<out K, V>)

putIfAbsent

open override fun putIfAbsent(p0: K, p1: V): V?

putMapEntries

fun putMapEntries(p0: MutableMap<out K, out V>, p1: Boolean)

putVal

fun putVal( p0: Int, p1: K, p2: V, p3: Boolean, p4: Boolean): V

reinitialize

open override fun reinitialize()

remove

open override fun remove(key: K): V?

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

removeNode

fun removeNode( p0: Int, p1: Any, p2: Any, p3: Boolean, p4: Boolean): HashMap.Node<K, V>

replace

open override fun replace(p0: K, p1: V): V?

open override fun replace( p0: K, p1: V, p2: V): Boolean

replaceAll

open override fun replaceAll(p0: BiFunction<in K, in V, out V>)

replacementNode

open override fun replacementNode(p0: HashMap.Node<K, V>, p1: HashMap.Node<K, V>): HashMap.Node<K, V>

replacementTreeNode

open override fun replacementTreeNode(p0: HashMap.Node<K, V>, p1: HashMap.Node<K, V>): HashMap.TreeNode<K, V>

resize

fun resize(): Array<HashMap.Node<K, V>>

toString

open override fun toString(): String

treeifyBin

fun treeifyBin(p0: Array<HashMap.Node<K, V>>, p1: Int)

valuesToArray

override fun <T : Any> valuesToArray(p0: Array<T>): Array<T>

Properties

accessOrder

val accessOrder: Boolean

entries

open override val entries: MutableSet<MutableMap.MutableEntry<K, V>>

entrySet

val entrySet: MutableSet<MutableMap.MutableEntry<K, V>>

head

val head: LinkedHashMap.Entry<K, V>

keys

open override val keys: MutableSet<K>

keySet

val keySet: MutableSet<K>

loadFactor

val loadFactor: Float

modCount

val modCount: Int

size

open override val size: Int

val size: Int

table

val table: Array<HashMap.Node<K, V>>

tail

val tail: LinkedHashMap.Entry<K, V>

threshold

val threshold: Int

values

open override val values: MutableCollection<V>

val values: MutableCollection<V>