heapcache

This cache implementation is based on priority queue (see Heap).
It uses user-defined comparator to evaluate priorities of cached items. Items with lowest priorities will be evicted first.

Features:

• simple standard data structure;
• no write locks on get operations;
• capacity may be changed at any time.

Requirements

Go >= 1.11

Documentation

https://godoc.org/github.com/turboezh/heapcache

Examples

Cache

type Foo struct {
    Value int
    Timestamp time.Time
}
item1 := Foo{10, time.Now()}
item2 := Foo{20, time.Now().Add(time.Second)}
cache := New(10, func(a, b interface{}) bool {
    return a.(*Foo).Timestamp.Before(b.(*Foo).Timestamp)
})

Add item

cache.Add("one", &item1)
cache.Add("two", &item2)

Get item

item, exists := cache.Get("one")
if !exists {
    // `foo` doesn't exists in cache
    // `item` is nil
}
// cache returns `interface{}` so we need to assert type (if need so)
item = item.(*Foo) // = &item1

Check item

// check if cache contain all keys 
ok := cache.All("one", "two")
// check if cache contain any of keys 
ok := cache.Any("one", "two")

Remove item

// Remove returns false if there is no item in cache
wasRemoved := cache.Remove("one")

Support on Beerpay

Hey dude! Help me out for a couple of !