131 lines
2.6 KiB
Go
131 lines
2.6 KiB
Go
package memcache_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sandc/pkg/cache/memcache"
|
|
"time"
|
|
)
|
|
|
|
func ExampleCache() {
|
|
// use simple cache algorithm without options.
|
|
c := memcache.New[string, int]()
|
|
c.Set("a", 1)
|
|
gota, aok := c.Get("a")
|
|
gotb, bok := c.Get("b")
|
|
fmt.Println(gota, aok)
|
|
fmt.Println(gotb, bok)
|
|
// Output:
|
|
// 1 true
|
|
// 0 false
|
|
}
|
|
|
|
func ExampleNewContext() {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
// use simple cache algorithm without options.
|
|
// an internal janitor will be stopped if specified the context is cancelled.
|
|
c := memcache.NewContext(ctx, memcache.WithJanitorInterval[string, int](3*time.Second))
|
|
c.Set("a", 1)
|
|
gota, aok := c.Get("a")
|
|
gotb, bok := c.Get("b")
|
|
fmt.Println(gota, aok)
|
|
fmt.Println(gotb, bok)
|
|
// Output:
|
|
// 1 true
|
|
// 0 false
|
|
}
|
|
|
|
func ExampleAsClock() {
|
|
// use clock cache algorithm.
|
|
c := memcache.New(memcache.AsClock[string, int]())
|
|
c.Set("a", 1)
|
|
gota, aok := c.Get("a")
|
|
gotb, bok := c.Get("b")
|
|
fmt.Println(gota, aok)
|
|
fmt.Println(gotb, bok)
|
|
// Output:
|
|
// 1 true
|
|
// 0 false
|
|
}
|
|
|
|
func ExampleWithExpiration() {
|
|
c := memcache.New(memcache.AsFIFO[string, int]())
|
|
exp := 250 * time.Millisecond
|
|
c.Set("a", 1, memcache.WithExpiration(exp))
|
|
|
|
// check item is set.
|
|
gota, aok := c.Get("a")
|
|
fmt.Println(gota, aok)
|
|
|
|
// set again
|
|
c.Set("a", 2, memcache.WithExpiration(exp))
|
|
gota2, aok2 := c.Get("a")
|
|
fmt.Println(gota2, aok2)
|
|
|
|
// waiting expiration.
|
|
time.Sleep(exp + 100*time.Millisecond) // + buffer
|
|
|
|
gota3, aok3 := c.Get("a") // expired
|
|
fmt.Println(gota3, aok3)
|
|
// Output:
|
|
// 1 true
|
|
// 2 true
|
|
// 0 false
|
|
}
|
|
|
|
func ExampleCache_Delete() {
|
|
c := memcache.New(memcache.AsMRU[string, int]())
|
|
c.Set("a", 1)
|
|
c.Delete("a")
|
|
gota, aok := c.Get("a")
|
|
fmt.Println(gota, aok)
|
|
// Output:
|
|
// 0 false
|
|
}
|
|
|
|
func ExampleCache_Keys() {
|
|
c := memcache.New(memcache.AsLFU[string, int]())
|
|
c.Set("a", 1)
|
|
c.Set("b", 1)
|
|
c.Set("c", 1)
|
|
fmt.Println(c.Keys())
|
|
// Output:
|
|
// [a b c]
|
|
}
|
|
|
|
func ExampleCache_Contains() {
|
|
c := memcache.New(memcache.AsLRU[string, int]())
|
|
c.Set("a", 1)
|
|
fmt.Println(c.Contains("a"))
|
|
fmt.Println(c.Contains("b"))
|
|
// Output:
|
|
// true
|
|
// false
|
|
}
|
|
|
|
func ExampleNewNumber() {
|
|
nc := memcache.NewNumber[string, int]()
|
|
nc.Set("a", 1)
|
|
nc.Set("b", 2, memcache.WithExpiration(time.Minute))
|
|
av := nc.Increment("a", 1)
|
|
gota, aok := nc.Get("a")
|
|
|
|
bv := nc.Decrement("b", 1)
|
|
gotb, bok := nc.Get("b")
|
|
|
|
// not set keys
|
|
cv := nc.Increment("c", 100)
|
|
dv := nc.Decrement("d", 100)
|
|
fmt.Println(av, gota, aok)
|
|
fmt.Println(bv, gotb, bok)
|
|
fmt.Println(cv)
|
|
fmt.Println(dv)
|
|
// Output:
|
|
// 2 2 true
|
|
// 1 1 true
|
|
// 100
|
|
// -100
|
|
}
|