mapsglmaps/com.xweather.mapsgl.utils/LRUCache

LRUCache

class LRUCache<String, V>(var capacity: Int, val ttl: Long, val onRemove: (key: String, value: V) -> Unit?) : MutableMap<String, V>

Constructors

LRUCache

constructor(capacity: Int, ttl: Long, onRemove: (key: String, value: V) -> Unit?)

Properties

cache

val cache: Map<String, LinkedListNode<Entry<String, V>>>

capacity

var capacity: Int

entries

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

first

val first: V?

keys

open override val keys: MutableSet<String>

last

val last: V?

onRemove

val onRemove: (key: String, value: V) -> Unit?

size

open override val size: Int

ttl

val ttl: Long

values

open override val values: MutableCollection<V>

Functions

clear

open override fun clear()

compute

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

computeIfAbsent

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

computeIfPresent

open fun computeIfPresent(p0: String, p1: BiFunction<in String, in V & Any, out V?>): V?

containsKey

open override fun containsKey(key: String): Boolean

containsValue

open override fun containsValue(value: V): Boolean

delete

fun delete(key: String): V?

entries

fun entries(): Sequence<Pair<String, V>>

forEach

fun forEach(fn: (entry: Entry<String, V>) -> Unit)

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

get

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

getOrDefault

open fun getOrDefault(key: String, defaultValue: V): V

has

fun has(key: String): Boolean

isEmpty

open override fun isEmpty(): Boolean

keys

fun keys(): Sequence<String>

merge

open fun merge(p0: String, p1: V & Any, p2: BiFunction<in V & Any, in V & Any, out V?>): V?

peek

fun peek(key: String): V?

put

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

putAll

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

putIfAbsent

open fun putIfAbsent(p0: String, p1: V): V?

remove

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

open fun remove(key: String, value: V): Boolean

replace

open fun replace(p0: String, p1: V): V?

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

replaceAll

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

set

operator fun set(key: String, value: V)

values

fun values(): Sequence<V>