cache.go

package gg

import (
	r "reflect"
	"sync"
)

// Type-inferring shortcut for creating a `Cache` of the given type.
func CacheOf[
	Key comparable,
	Val any,
	Ptr Initer1Ptr[Val, Key],
]() *Cache[Key, Val, Ptr] {
	return new(Cache[Key, Val, Ptr])
}

/*
Concurrency-safe cache that creates and initializes values on demand, using keys
as inputs. Does not support eviction or expiration. Suitable when values are
unambiguously related to keys and don't need to be evicted or refreshed.
*/
type Cache[
	Key comparable,
	Val any,
	Ptr Initer1Ptr[Val, Key],
] struct {
	Map  map[Key]Ptr
	Lock sync.RWMutex
}

/*
Shortcut for using `.Ptr` and dereferencing the result. May be invalid if the
resulting value is non-copyable, for example when it contains a mutex.
*/
func (self *Cache[Key, Val, Ptr]) Get(key Key) Val { return *self.Ptr(key) }

/*
Returns the cached value for the given key, by pointer. If the value did not
previously exist, idempotently initializes it by calling `.Init` and caches the
result. For any given key, the value is initialized exactly once, even if
multiple goroutines are trying to access it simultaneously.
*/
func (self *Cache[Key, Val, Ptr]) Ptr(key Key) Ptr {
	ptr := self.get(key)
	if ptr != nil {
		return ptr
	}

	defer Lock(&self.Lock).Unlock()

	ptr = self.Map[key]
	if ptr != nil {
		return ptr
	}

	ptr = new(Val)
	ptr.Init(key)
	MapInit(&self.Map)[key] = ptr
	return ptr
}

func (self *Cache[Key, _, Ptr]) get(key Key) Ptr {
	defer Lock(self.Lock.RLocker()).Unlock()
	return self.Map[key]
}

// Deletes the value for the given key.
func (self *Cache[Key, _, _]) Del(key Key) {
	defer Lock(&self.Lock).Unlock()
	delete(self.Map, key)
}

// Type-inferring shortcut for creating a `TypeCache` of the given type.
func TypeCacheOf[Val any, Ptr Initer1Ptr[Val, r.Type]]() *TypeCache[Val, Ptr] {
	return new(TypeCache[Val, Ptr])
}

/*
Tool for storing information derived from `reflect.Type` that can be generated
once and then cached. Used internally. All methods are concurrency-safe.
*/
type TypeCache[Val any, Ptr Initer1Ptr[Val, r.Type]] struct {
	Map  map[r.Type]Ptr
	Lock sync.RWMutex
}

/*
Shortcut for using `.Ptr` and dereferencing the result. May be invalid if the
resulting value is non-copyable, for example when it contains a mutex.
*/
func (self *TypeCache[Val, Ptr]) Get(key r.Type) Val { return *self.Ptr(key) }

/*
Returns the cached value for the given key. If the value did not previously
exist, idempotently initializes it by calling `.Init` (by pointer) and caches
the result. For any given key, the value is initialized exactly once, even if
multiple goroutines are trying to access it simultaneously.
*/
func (self *TypeCache[Val, Ptr]) Ptr(key r.Type) Ptr {
	ptr := self.get(key)
	if ptr != nil {
		return ptr
	}

	defer Lock(&self.Lock).Unlock()

	ptr = self.Map[key]
	if ptr != nil {
		return ptr
	}

	ptr = new(Val)
	ptr.Init(key)

	if self.Map == nil {
		self.Map = map[r.Type]Ptr{}
	}
	self.Map[key] = ptr

	return ptr
}

func (self *TypeCache[Val, Ptr]) get(key r.Type) Ptr {
	defer Lock(self.Lock.RLocker()).Unlock()
	return self.Map[key]
}