cachedrepo

README

cached-repository

a basic repository to support cached data in memory and is based LRU-K cache replacing algorithm

TODOs

• LRU-1 & LRU-K

• Cached-Repository demo

• LRU-K concurrent safe

• LRU-1 concurrent safe

Quick Start

simple

package main

import (
	"fmt"

	cachedrepo "github.com/yeqown/cached-repository"
	"github.com/yeqown/cached-repository/lru"
)

func main() {
	c, err := lru.NewLRUK(2, 2, 10, nil)
	if err != nil {
		panic(err)
	}
	ca := cachedrepo.New(c)
	v, ok := ca.Get("key1")
	fmt.Printf("ca.Get('key1')=%v,%v\n", v, ok)

	// put key1, twice means 2 times visit
	ca.Put("key1", "value1")
	ca.Put("key1", "value1")
	v, ok = ca.Get("key1")
	fmt.Printf("ca.Get('key1')=%v,%v\n", v, ok)

	// update key1
	ca.Update("key1", "value111")
	v, ok = ca.Get("key1")
	fmt.Printf("ca.Get('key1')=%v,%v\n", v, ok)

	// put key2, key3 twice
	ca.Put("key2", "value2")
	ca.Put("key2", "value2")
	ca.Put("key3", "value3")
	ca.Put("key3", "value3")

	// query key1 again
	v, ok = ca.Get("key1")
	fmt.Printf("ca.Get('key1')=%v,%v\n", v, ok)

	// query key2
	v, ok = ca.Get("key2")
	fmt.Printf("ca.Get('key2')=%v,%v\n", v, ok)

	// query key3
	v, ok = ca.Get("key3")
	fmt.Printf("ca.Get('key3')=%v,%v\n", v, ok)
}

ca.Get('key1')=<nil>,false
ca.Get('key1')=value1,true
ca.Get('key1')=value111,true
ca.Get('key1')=<nil>,false
ca.Get('key2')=value2,true
ca.Get('key3')=value3,true

Examples

• simple
• cache repository

Documentation

Index

• type CacheAlgor
  • func New(c lru.Cache) CacheAlgor
• type LRUCacheAlgor
  • func (a LRUCacheAlgor) Delete(key interface{})
  • func (a LRUCacheAlgor) Get(key interface{}) (value interface{}, ok bool)
  • func (a LRUCacheAlgor) Put(key, value interface{})
  • func (a LRUCacheAlgor) Update(key, value interface{})

Types

type CacheAlgor

type CacheAlgor interface {
	Put(key, value interface{})
	Get(key interface{}) (value interface{}, ok bool)
	Update(key, value interface{})
	Delete(key interface{})
}

CacheAlgor is an interface implements different alg.

func New

func New(c lru.Cache) CacheAlgor

New .

type LRUCacheAlgor

type LRUCacheAlgor struct {
	// contains filtered or unexported fields
}

LRUCacheAlgor .

func (LRUCacheAlgor) Delete

func (a LRUCacheAlgor) Delete(key interface{})

Delete of LRUCacheAlgor

func (LRUCacheAlgor) Get

func (a LRUCacheAlgor) Get(key interface{}) (value interface{}, ok bool)

Get of LRUCacheAlgor

func (LRUCacheAlgor) Put

func (a LRUCacheAlgor) Put(key, value interface{})

Put of LRUCacheAlgor

func (LRUCacheAlgor) Update

func (a LRUCacheAlgor) Update(key, value interface{})

Update of LRUCacheAlgor