fetch.go

package ttlmap

import (
	"errors"
	"time"
)

// ErrTypeMismatch is returned when the cached value cannot be cast to the requested generic type.
var ErrTypeMismatch = errors.New("ttlmap: cached value has different type")

// Fetch returns a strictly typed value from the cache, fetching from the provided source function when missing.
func Fetch[T any](m CacheMap, key string, source func(string) (T, error)) (T, error) {
	return FetchWithCustomDuration[T](m, key, func(k string) (T, *time.Duration, error) {
		value, err := source(k)
		return value, nil, err
	})
}

func FetchWithCustomDuration[T any](m CacheMap, key string, source func(string) (T, *time.Duration, error)) (T, error) {
	var zero T
	var returnValue T
	var okCast bool

	shard := m.GetShard(key)
	shard.RLock()
	itm, ok := shard.items[key]
	if ok {
		returnValue, okCast = itm.GetValue().(T)
		shard.RUnlock()
		if !okCast {
			return zero, ErrTypeMismatch
		}

		if !itm.Expired() {
			return returnValue, nil
		}

		if !itm.isUpdating && itm.updateMutex.TryLock() {
			itm.isUpdating = true
			go func() {
				// Update in the background to avoid cache call slow downs
				value, duration, err := source(key)
				if err == nil {
					m.Set(key, value, duration)
				}
				itm.updateMutex.Unlock()
				itm.isUpdating = false
			}()
		}

		// Item has expired, but another thread is updateMutex
		return returnValue, nil
	}
	shard.RUnlock()
	shard.Lock()
	defer shard.Unlock()

	itm, ok = shard.items[key]
	if ok {
		// check the value was not already processed when waiting for the lock
		returnValue, okCast = itm.GetValue().(T)
		if !okCast {
			return zero, ErrTypeMismatch
		}
		return returnValue, nil
	}

	value, duration, err := source(key)
	if err == nil {
		if duration == nil {
			duration = &m.options.defaultCacheDuration
		}
		itm = newItem(value, *duration, time.Now().Add(m.options.maxLifetime), nil)
		shard.items[key] = itm
	}
	return value, err
}