package lru

Import Path
	gorm.io/gorm/internal/lru (on go.dev)

Dependency Relation
	imports 2 packages, and imported by one package

Involved Source Files

	    lru.go
Package-Level Type Names (total 4)

	/* sort by: alphabet | popularity */
	 type Entry[K, V] (struct)

		Type Parameters:
			K: comparable
			V: any

		Entry is an LRU Entry

		Fields (total 4)
			ExpireBucket uint8
				The expiry bucket item was put in, optional

			ExpiresAt time.Time
				The time this element would be cleaned up, optional

			Key K
				The LRU Key of this element.

			Value V
				The Value stored with this element.

		Methods (only one)
			(*Entry[K, V]) PrevEntry() *Entry[K, V]
				PrevEntry returns the previous list element or nil.

		As Outputs Of (at least 4)
			func (*Entry)[K, V].PrevEntry() *Entry[K, V]
			func (*LruList)[K, V].Back() *Entry[K, V]
			func (*LruList)[K, V].PushFront(k K, v V) *Entry[K, V]
			func (*LruList)[K, V].PushFrontExpirable(k K, v V, expiresAt time.Time) *Entry[K, V]
		As Inputs Of (at least 2)
			func (*LruList)[K, V].MoveToFront(e *Entry[K, V])
			func (*LruList)[K, V].Remove(e *Entry[K, V]) V

	 type EvictCallback[K, V] (func)

		Type Parameters:
			K: comparable
			V: any

		EvictCallback is used to get a callback when a cache entry is evicted

		As Inputs Of (at least one exported)
			func NewLRU[K, V](size int, onEvict EvictCallback[K, V], ttl time.Duration) *LRU[K, V]

	 type LRU[K, V] (struct)

		Type Parameters:
			K: comparable
			V: any

		LRU implements a thread-safe LRU with expirable entries.

		Methods (total 14)
			(*LRU[K, V]) Add(key K, value V) (evicted bool)
				Add adds a value to the cache. Returns true if an eviction occurred.
				Returns false if there was no eviction: the item was already in the cache,
				or the size was not exceeded.

			(*LRU[K, V]) Cap() int
				Cap returns the capacity of the cache

			(*LRU[K, V]) Contains(key K) (ok bool)
				Contains checks if a key is in the cache, without updating the recent-ness
				or deleting it for being stale.

			(*LRU[K, V]) Get(key K) (value V, ok bool)
				Get looks up a key's value from the cache.

			(*LRU[K, V]) GetOldest() (key K, value V, ok bool)
				GetOldest returns the oldest entry

			(*LRU[K, V]) KeyValues() map[K]V
			(*LRU[K, V]) Keys() []K
				Keys returns a slice of the keys in the cache, from oldest to newest.
				Expired entries are filtered out.

			(*LRU[K, V]) Len() int
				Len returns the number of items in the cache.

			(*LRU[K, V]) Peek(key K) (value V, ok bool)
				Peek returns the key value (or undefined if not found) without updating
				the "recently used"-ness of the key.

			(*LRU[K, V]) Purge()
				Purge clears the cache completely.
				onEvict is called for each evicted key.

			(*LRU[K, V]) Remove(key K) bool
				Remove removes the provided key from the cache, returning if the
				key was contained.

			(*LRU[K, V]) RemoveOldest() (key K, value V, ok bool)
				RemoveOldest removes the oldest item from the cache.

			(*LRU[K, V]) Resize(size int) (evicted int)
				Resize changes the cache size. Size of 0 means unlimited.

			(*LRU[K, V]) Values() []V
				Values returns a slice of the values in the cache, from oldest to newest.
				Expired entries are filtered out.

		As Outputs Of (at least one exported)
			func NewLRU[K, V](size int, onEvict EvictCallback[K, V], ttl time.Duration) *LRU[K, V]

	 type LruList[K, V] (struct)

		Type Parameters:
			K: comparable
			V: any

		LruList represents a doubly linked list.
		The zero Value for LruList is an empty list ready to use.

		Methods (total 7)
			(*LruList[K, V]) Back() *Entry[K, V]
				Back returns the last element of list l or nil if the list is empty.

			(*LruList[K, V]) Init() *LruList[K, V]
				Init initializes or clears list l.

			(*LruList[K, V]) Length() int
				Length returns the number of elements of list l.
				The complexity is O(1).

			(*LruList[K, V]) MoveToFront(e *Entry[K, V])
				MoveToFront moves element e to the front of list l.
				If e is not an element of l, the list is not modified.
				The element must not be nil.

			(*LruList[K, V]) PushFront(k K, v V) *Entry[K, V]
				PushFront inserts a new element e with value v at the front of list l and returns e.

			(*LruList[K, V]) PushFrontExpirable(k K, v V, expiresAt time.Time) *Entry[K, V]
				PushFrontExpirable inserts a new expirable element e with Value v at the front of list l and returns e.

			(*LruList[K, V]) Remove(e *Entry[K, V]) V
				Remove removes e from its list, decrements l.len

		As Outputs Of (at least 2)
			func NewList[K, V]() *LruList[K, V]
			func (*LruList)[K, V].Init() *LruList[K, V]


Package-Level Functions (total 2)

	 func NewList[K, V]() *LruList[K, V]

		Type Parameters:
			K: comparable
			V: any

		NewList returns an initialized list.

	 func NewLRU[K, V](size int, onEvict EvictCallback[K, V], ttl time.Duration) *LRU[K, V]

		Type Parameters:
			K: comparable
			V: any

		NewLRU returns a new thread-safe cache with expirable entries.
		
		Size parameter set to 0 makes cache of unlimited size, e.g. turns LRU mechanism off.
		
		Providing 0 TTL turns expiring off.
		
		Delete expired entries every 1/100th of ttl value. Goroutine which deletes expired entries runs indefinitely.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.