package net.sergeych.collections /** * Most Recently Used keys Cache. * Maintains the specified size, removed least used elements on insertion. Element usage is * when it is inserted, updated or accessed (with [get]). Least recently used (LRU) keys * are automatically removed to maintain the [maxSize]. * * Note that the cost, [MRUCache] is slower than [MutableMap]. */ class MRUCache(val maxSize: Int, private val cache: LinkedHashMap = LinkedHashMap() ): MutableMap by cache { private fun checkSize() { while(cache.size > maxSize) { cache.remove(cache.keys.first()) } } /** * Put the [value] associated with [key] which becomes MRU whether it existed in the cache or was added now. * * If [size] == [maxSize] LRU key will be dropped. * * @return old value for the [key] or null */ override fun put(key: K, value: V): V? { // we need it to become MRU, so we remove it to clear its position val oldValue = cache.remove(key) // now we always add, not update, so it will become MRU element: cache.put(key,value).also { checkSize() } return oldValue } /** * Put all the key-value pairs, this is exactly same as calling [put] in the same * order. Note that is the [from] map is not linked and its size is greater than * [maxSize], some unpredictable keys will not be added. To be exact, only last * [maxSize] keys will be added by the order providing by [from] map entries * enumerator. * * If from is [LinkedHashMap] or like, onl */ override fun putAll(from: Map) { // maybe we should optimize it not to add unnecessary first keys for( e in from) { put(e.key,e.value) checkSize() } } /** * Get the value associated with the [key]. It makes the [key] a MRU (last to delete) */ override fun get(key: K): V? { return cache[key]?.also { cache.remove(key) cache[key] = it } } override fun toString(): String = cache.toString() }