package ttl_memory_cache import ( "sync" "time" ) type Cache struct { expiration *time.Duration cleanupInterval *time.Duration mu sync.RWMutex items map[string]Item } type Item struct { Value interface{} ExpiredAt *time.Time } func NewCache(c Config) *Cache { cache := Cache{ items: make(map[string]Item), expiration: c.expiration, cleanupInterval: c.cleanupInterval, } if c.cleanupInterval != nil { go cache.cleanupWorker() } return &cache } func (c *Cache) Set(key string, value interface{}, expiration *time.Duration) { item := Item{ Value: value, } if expiration != nil { expiredAt := time.Now().Add(*expiration) item.ExpiredAt = &expiredAt } else if c.expiration != nil { expiredAt := time.Now().Add(*c.expiration) item.ExpiredAt = &expiredAt } c.mu.Lock() defer c.mu.Unlock() c.items[key] = item } func (c *Cache) Get(key string) (interface{}, bool) { c.mu.RLock() defer c.mu.RUnlock() item, found := c.items[key] if !found { return nil, false } if item.ExpiredAt != nil && time.Now().After(*item.ExpiredAt) { c.Delete(key) return nil, false } return item.Value, true } func (c *Cache) Delete(key string) { c.mu.Lock() defer c.mu.Unlock() if _, found := c.items[key]; found { delete(c.items, key) } } func (c *Cache) cleanupWorker() { for { <-time.After(*c.cleanupInterval) if len(c.items) == 0 { return } now := time.Now() for key, item := range c.items { if item.ExpiredAt != nil && now.After(*item.ExpiredAt) { c.Delete(key) } } } }