[type:feat] support xmap and lru.

* [type:feat] support xmap and lru. (#76)

* [type:feat] support xmap and lru.

Co-authored-by: moremind <hefengen@hotmail.com>

Author: yunlongn

gox/containerx/lru/lru.go

@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2022, AcmeStack
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lru
+
+import (
+	"github.com/acmestack/godkits/gox/containerx/xmap"
+)
+
+// LRU
+//  @Description: interface LRU
+//
+type LRU interface {
+	xmap.IMap
+
+	Purge()
+}
+
+// SimpleLru
+//  @Description: type SimpleLru
+//
+type SimpleLru struct {
+	m     map[interface{}]*QueueElem
+	queue *LruQueue
+
+	cap int
+}
+
+// NewLruCache
+//  @Description: new a appoint capacity SimpleLru
+//  @param capacity
+//  @return *SimpleLru
+func NewLruCache(capacity int) *SimpleLru {
+	ret := &SimpleLru{
+		m:   map[interface{}]*QueueElem{},
+		cap: capacity,
+	}
+	ret.queue = NewLruQueue(capacity)
+	ret.queue.AddListener(ret)
+	return ret
+}
+
+func (m *SimpleLru) PostTouch(v interface{}) {
+}
+
+func (m *SimpleLru) PostInsert(v interface{}) {
+}
+
+// PostDelete
+//  import PostDelete
+//  @Description: Purge data
+//  @receiver m
+func (m *SimpleLru) PostDelete(v interface{}) {
+	key := v.([2]interface{})[0]
+	delete(m.m, key)
+}
+
+func (m *SimpleLru) hit(key interface{}, hit bool) {
+
+}
+
+// Purge
+//  @Description: Purge data
+//  @receiver m
+func (m *SimpleLru) Purge() {
+	m.queue.listeners = nil
+	m.queue.list = nil
+	m.queue = nil
+}
+
+// Put
+//  @Description: put value to lru
+//  @receiver m
+//  @param key key
+//  @param value value
+func (m *SimpleLru) Put(key, value interface{}) {
+	e, ok := m.m[key]
+	if ok {
+		e.Value = [2]interface{}{key, value}
+		m.queue.Touch(e)
+	} else {
+		elem := m.queue.Insert([2]interface{}{key, value})
+		m.m[key] = elem
+	}
+}
+
+// Get
+//  @Description: Get key to value
+//  @receiver m SimpleLru
+//  @param key key
+//  @return value value
+//  @return loaded success is true, fail is false
+func (m *SimpleLru) Get(key interface{}) (value interface{}, loaded bool) {
+	v, ok := m.m[key]
+	if ok {
+		m.queue.Touch(v)
+		// 命中
+		m.hit(key, true)
+		return v.Value.([2]interface{})[1], true
+	} else {
+		// 未命中
+		m.hit(key, false)
+		return nil, false
+	}
+}
+
+// Delete
+//  @Description: delete by key
+//  @receiver m
+//  @param key
+func (m *SimpleLru) Delete(key interface{}) {
+	v, ok := m.m[key]
+	if ok {
+		m.queue.Delete(v)
+	}
+}
+
+// Size
+//  @Description: get Lru queue Size
+//  @receiver m
+//  @return int
+func (m *SimpleLru) Size() int {
+	return len(m.m)
+}

gox/containerx/lru/lru_test.go

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2022, AcmeStack
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lru
+
+import (
+	"github.com/acmestack/godkits/assert"
+	"testing"
+)
+
+func TestNewLruCache(t *testing.T) {
+
+	simpleLru := NewLruCache(2)
+
+	simpleLru.Put("1", "1")
+	simpleLru.Put("2", "2")
+	simpleLru.Put("4", "4")
+	// After exceeding capacity, Check whether LRU can delete header elements
+	_value1, _ := simpleLru.Get("1")
+	assert.NotEqual(t, _value1, nil, "get key 1 value Should be 1")
+
+	// check value is normal
+	_value4, _ := simpleLru.Get("4")
+	assert.NotEqual(t, _value4, "4", "get key 4 value Should be 4")
+
+}
+
+func TestSimpleLru_Get(t *testing.T) {
+	simpleLru := NewLruCache(2)
+
+	simpleLru.Put("1", "1")
+	simpleLru.Put("2", "2")
+	simpleLru.Put("2", "3")
+	// check put repeat key
+	_value1, _ := simpleLru.Get("2")
+	assert.NotEqual(t, _value1, "3", "get key 2 value Should be 3")
+
+}
+
+func TestSimpleLru_Delete(t *testing.T) {
+	simpleLru := NewLruCache(2)
+
+	simpleLru.Put("1", "1")
+	simpleLru.Delete("1")
+	// check delete key
+	_value1, _ := simpleLru.Get("1")
+	assert.NotEqual(t, _value1, nil, "get key 1 value Should be nil")
+}
+
+func TestSimpleLru_Size(t *testing.T) {
+	simpleLru := NewLruCache(2)
+
+	simpleLru.Put("1", "1")
+	simpleLru.Put("2", "2")
+
+	// check size
+	_size := simpleLru.Size()
+	assert.NotEqual(t, _size, 2, "get size Should be 2")
+}
+
+func TestSimpleLru_Purge(t *testing.T) {
+	simpleLru := NewLruCache(2)
+	simpleLru.Put("1", "1")
+	simpleLru.Put("2", "2")
+
+	simpleLru.Purge()
+	// check Purge
+	assert.NotEqual(t, simpleLru.queue, (*LruQueue)(nil), "get simpleLru.queue Should be nil")
+}

gox/containerx/lru/queue.go

@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2022, AcmeStack
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lru
+
+import "container/list"
+
+type QueueElem list.Element
+
+// QueueListener
+//  @Description: QueueListener
+//
+type QueueListener interface {
+
+	// PostTouch
+	//  @Description: Element hit, which is called after the element is moved to the queue head
+	//  @param v
+	//
+	PostTouch(v interface{})
+
+	// PostInsert
+	//  @Description: Called after the element is newly added to the queue header
+	//  @param v
+	//
+	PostInsert(v interface{})
+
+	// PostDelete
+	//  @Description: Called after the element is deleted from the queue
+	//  @param v
+	//
+	PostDelete(v interface{})
+}
+
+type Queue interface {
+	AddListener(listener QueueListener)
+
+	Touch(elem *QueueElem)
+
+	Move(other *LruQueue, elem *QueueElem, notify bool) *QueueElem
+
+	Insert(v interface{}) *QueueElem
+
+	Delete(elem *QueueElem)
+}
+
+// LruQueue struct
+//  @Description: LruQueue
+//
+type LruQueue struct {
+	list      *list.List
+	cap       int
+	listeners []QueueListener
+}
+
+// NewLruElement
+//  @Description: NewLruElement by value
+//  @param v
+//  @return *QueueElem
+func NewLruElement(v interface{}) *QueueElem {
+	return &QueueElem{
+		Value: v,
+	}
+}
+
+// NewLruQueue
+//  @Description: new a appoint capacity NewLruQueue
+//  @param cap capacity
+//  @return *LruQueue
+func NewLruQueue(cap int) *LruQueue {
+	return &LruQueue{
+		list:      list.New(),
+		cap:       cap,
+		listeners: []QueueListener{},
+	}
+}
+
+// AddListener
+//  @Description:
+//  @receiver q
+//  @param listener
+func (q *LruQueue) AddListener(listener QueueListener) {
+	q.listeners = append(q.listeners, listener)
+}
+
+// Touch
+//  @Description:
+//  @receiver q
+//  @param elem
+func (q *LruQueue) Touch(elem *QueueElem) {
+	if elem != nil {
+		q.list.MoveToFront((*list.Element)(elem))
+		for _, l := range q.listeners {
+			l.PostTouch(elem.Value)
+		}
+	}
+}
+
+// Move
+//  @Description:
+//  @receiver q
+//  @param other
+//  @param elem
+//  @param notify
+//  @return *QueueElem
+func (q *LruQueue) Move(other *LruQueue, elem *QueueElem, notify bool) *QueueElem {
+	if other == nil || elem == nil {
+		return nil
+	}
+	v := q.list.Remove((*list.Element)(elem))
+	if notify {
+		for _, l := range q.listeners {
+			l.PostDelete(elem.Value)
+		}
+	}
+
+	elem = (*QueueElem)(other.list.PushFront(v))
+	if notify {
+		for _, l := range q.listeners {
+			l.PostInsert(elem.Value)
+		}
+	}
+	return elem
+}
+
+// Insert
+//  @Description:
+//  @receiver q
+//  @param v
+//  @return *QueueElem
+func (q *LruQueue) Insert(v interface{}) *QueueElem {
+	if q.list.Len() == q.cap {
+		e := q.list.Back()
+		if e != nil {
+			q.Delete((*QueueElem)(e))
+		}
+	}
+
+	e := q.list.PushFront(v)
+	for _, l := range q.listeners {
+		l.PostInsert(v)
+	}
+	return (*QueueElem)(e)
+}
+
+// Delete
+//  @Description:
+//  @receiver q
+//  @param elem
+func (q *LruQueue) Delete(elem *QueueElem) {
+	v := q.list.Remove((*list.Element)(elem))
+	for _, l := range q.listeners {
+		l.PostDelete(v)
+	}
+}