gitee.com/sy_183/go-common@v1.0.5-0.20231205030221-958cfe129b47/container/linked-map.go

package container

import "gitee.com/sy_183/go-common/maps"

type LinkedMapEntry[K comparable, V any] struct {
	key   K
	value V
	next  *LinkedMapEntry[K, V]
	prev  *LinkedMapEntry[K, V]
}

func NewLinkedMapEntry[K comparable, V any](key K, value V) *LinkedMapEntry[K, V] {
	return &LinkedMapEntry[K, V]{key: key, value: value}
}

func (e *LinkedMapEntry[K, V]) Key() K {
	return e.key
}

func (e *LinkedMapEntry[K, V]) Value() V {
	return e.value
}

func (e *LinkedMapEntry[K, V]) Entry() maps.Entry[K, V] {
	return maps.NewEntry(e.key, e.value)
}

func (e *LinkedMapEntry[K, V]) Set(v V) {
	e.value = v
}

func (e *LinkedMapEntry[K, V]) Next() *LinkedMapEntry[K, V] {
	if e.next == nil || e.next.next == nil {
		return nil
	}
	return e.next
}

func (e *LinkedMapEntry[K, V]) Prev() *LinkedMapEntry[K, V] {
	if e.prev == nil || e.prev.prev == nil {
		return nil
	}
	return e.prev
}

func (e *LinkedMapEntry[K, V]) Removed() bool {
	return e.next == nil && e.prev == nil
}

type LinkedMap[K comparable, V any] struct {
	entries []*LinkedMapEntry[K, V]
	head    *LinkedMapEntry[K, V]
	tail    *LinkedMapEntry[K, V]
	m       map[K]*LinkedMapEntry[K, V]
}

func NewLinkedMap[K comparable, V any](entries int, size int) *LinkedMap[K, V] {
	m := &LinkedMap[K, V]{
		entries: make([]*LinkedMapEntry[K, V], entries),
		head:    new(LinkedMapEntry[K, V]),
		tail:    new(LinkedMapEntry[K, V]),
		m:       make(map[K]*LinkedMapEntry[K, V], size),
	}
	m.init()
	return m
}

func (m *LinkedMap[K, V]) init() {
	rawEntries := make([]LinkedMapEntry[K, V], len(m.entries))
	for i := range rawEntries {
		m.entries[i] = &rawEntries[i]
	}
	m.entries = m.entries[:0]
	m.head.next = m.tail
	m.tail.prev = m.head
}

func (m *LinkedMap[K, V]) Init(entries int, size int) {
	*m = LinkedMap[K, V]{
		entries: make([]*LinkedMapEntry[K, V], entries),
		head:    new(LinkedMapEntry[K, V]),
		tail:    new(LinkedMapEntry[K, V]),
		m:       make(map[K]*LinkedMapEntry[K, V], size),
	}
	m.init()
}

func (m *LinkedMap[K, V]) IsNil() bool {
	return m.m == nil
}

// Len 返回 LinkedMap 的长度
func (m *LinkedMap[K, V]) Len() int {
	return len(m.m)
}

// Empty 判断 LinkedMap 是否为空
func (m *LinkedMap[K, V]) Empty() bool {
	return len(m.m) == 0
}

// Has 判断 LinkedMap 中是否包含指定 key
func (m *LinkedMap[K, V]) Has(key K) bool {
	_, has := m.m[key]
	return has
}

// Get 获取指定 key 对应的值，如果不存在则返回对应的零值
func (m *LinkedMap[K, V]) Get(key K) (value V) {
	if e, exist := m.m[key]; exist {
		return e.value
	}
	return
}

// GetEntry 获取指定 key 的对应的键值对，返回 nil 则表示未找到指定的 key
func (m *LinkedMap[K, V]) GetEntry(key K) *LinkedMapEntry[K, V] {
	return m.m[key]
}

// Load 获取指定 key 对应的值，返回值 exist 为 false 则表示未找到对应的值
func (m *LinkedMap[K, V]) Load(key K) (value V, exist bool) {
	e, exist := m.m[key]
	if exist {
		return e.value, true
	}
	return
}

// HeadKey 获取第一个键值对的 key，返回值 exist 为 false 则表示 LinkedMap 为空
func (m *LinkedMap[K, V]) HeadKey() (key K, exist bool) {
	return m.head.next.key, len(m.m) != 0
}

// Head 获取第一个键值对的值，返回值 exist 为 false 则表示 LinkedMap 为空
func (m *LinkedMap[K, V]) Head() (value V, exist bool) {
	return m.head.next.value, len(m.m) != 0
}

// HeadEntry 获取第一个键值对，返回 nil 则表示 LinkedMap 为空
func (m *LinkedMap[K, V]) HeadEntry() *LinkedMapEntry[K, V] {
	if len(m.m) == 0 {
		return nil
	}
	return m.head.next
}

// Tail 获取最后一个键值对的值，返回值 exist 为 false 则表示 LinkedMap 为空
func (m *LinkedMap[K, V]) Tail() (value V, exist bool) {
	return m.tail.prev.value, len(m.m) != 0
}

// TailEntry 获取第一个键值对，返回 nil 则表示 LinkedMap 为空
func (m *LinkedMap[K, V]) TailEntry() *LinkedMapEntry[K, V] {
	if len(m.m) == 0 {
		return nil
	}
	return m.tail.prev
}

func (m *LinkedMap[K, V]) Range(f func(key K, value V) bool) bool {
	var next *LinkedMapEntry[K, V]
	for cur := m.head.next; cur.next != nil; cur = next {
		next = cur.next
		if !f(cur.key, cur.value) {
			return false
		}
	}
	return true
}

func (m *LinkedMap[K, V]) RangeEntries(f func(e *LinkedMapEntry[K, V]) bool) bool {
	var next *LinkedMapEntry[K, V]
	for cur := m.head.next; cur.next != nil; cur = next {
		next = cur.next
		if !f(cur) {
			return false
		}
	}
	return true
}

func (m *LinkedMap[K, V]) Keys() (keys []K) {
	keys = make([]K, 0, len(m.m))
	for cur := m.head.next; cur.next != nil; cur = cur.next {
		keys = append(keys, cur.key)
	}
	return
}

func (m *LinkedMap[K, V]) Values() (values []V) {
	values = make([]V, 0, len(m.m))
	for cur := m.head.next; cur.next != nil; cur = cur.next {
		values = append(values, cur.value)
	}
	return
}

func (m *LinkedMap[K, V]) Entries() (entries []maps.Entry[K, V]) {
	for cur := m.head.next; cur.next != nil; cur = cur.next {
		entries = append(entries, cur.Entry())
	}
	return
}

func (m *LinkedMap[K, V]) Map() map[K]V {
	mm := make(map[K]V, len(m.m))
	for cur := m.head.next; cur.next != nil; cur = cur.next {
		mm[cur.key] = cur.value
	}
	return mm
}

func (m *LinkedMap[K, V]) grow() int {
	l := len(m.entries)
	if l == cap(m.entries) {
		m.entries = append(m.entries, nil)
		m.entries = m.entries[:cap(m.entries)]
		rawEntries := make([]LinkedMapEntry[K, V], cap(m.entries)-l)
		for i := range rawEntries {
			m.entries[i+l] = &rawEntries[i]
		}
		m.entries = m.entries[:l]
	}
	return l
}

func (m *LinkedMap[K, V]) newEntry(key K, value V) (e *LinkedMapEntry[K, V]) {
	l := m.grow()
	m.entries = m.entries[:l+1]
	e = m.entries[l]
	e.key = key
	e.value = value
	return m.entries[l]
}

func (m *LinkedMap[K, V]) freeEntry(e *LinkedMapEntry[K, V]) {
	l := len(m.entries)
	m.entries[l-1] = e
	m.entries = m.entries[:l-1]
}

func (m *LinkedMap[K, V]) addLink(e *LinkedMapEntry[K, V], p *LinkedMapEntry[K, V]) {
	e.prev = p
	e.next = p.next
	p.next.prev = e
	p.next = e
}

func (m *LinkedMap[K, V]) removeLink(e *LinkedMapEntry[K, V]) {
	e.prev.next = e.next
	e.next.prev = e.prev
	e.next, e.prev = nil, nil
}

func (m *LinkedMap[K, V]) push(e *LinkedMapEntry[K, V]) {
	m.m[e.key] = e
	m.addLink(e, m.tail.prev)
}

func (m *LinkedMap[K, V]) unshift(e *LinkedMapEntry[K, V]) {
	m.m[e.key] = e
	m.addLink(e, m.head)
}

func (m *LinkedMap[K, V]) insert(e, p *LinkedMapEntry[K, V]) {
	m.m[e.key] = e
	m.addLink(e, p)
}

func (m *LinkedMap[K, V]) remove(e *LinkedMapEntry[K, V]) {
	delete(m.m, e.key)
	m.removeLink(e)
	m.freeEntry(e)
}

// Store 设置或添加指定 key 的对应的值，如果存在则设置，不存在则添加到尾部
func (m *LinkedMap[K, V]) Store(key K, value V) {
	if e, exist := m.m[key]; exist {
		e.value = value
		return
	}
	m.push(m.newEntry(key, value))
}

// Set 与 StoreHead 作用相同
func (m *LinkedMap[K, V]) Set(key K, value V) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		e.value = value
		return
	}
	m.unshift(m.newEntry(key, value))
	return
}

// StoreHead 设置或添加指定 key 的对应的值，如果存在则设置并返回旧的值，不存在则添加到头部，返
// 回值 exist 为 true 则表示指定 key 对应的值存在
func (m *LinkedMap[K, V]) StoreHead(key K, value V) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		e.value = value
		return
	}
	m.unshift(m.newEntry(key, value))
	return
}

// StoreTail 设置或添加指定 key 的对应的值，如果存在则设置并返回旧的值，不存在则添加到尾部。返
// 回值 exist 为 true 则表示指定 key 对应的值存在
func (m *LinkedMap[K, V]) StoreTail(key K, value V) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		e.value = value
		return
	}
	m.push(m.newEntry(key, value))
	return
}

func (m *LinkedMap[K, V]) StoreBack(key K, value V, ref *LinkedMapEntry[K, V]) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		e.value = value
		return
	}
	m.insert(m.newEntry(key, value), ref)
	return
}

func (m *LinkedMap[K, V]) StoreFront(key K, value V, ref *LinkedMapEntry[K, V]) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		e.value = value
		return
	}
	m.insert(m.newEntry(key, value), ref.prev)
	return
}

// LoadOrStore 获取或添加指定 key 的对应的值，如果存在则获取，不存在则添加到尾部。返回值 exist
// 为 true 则表示指定 key 对应的值存在
func (m *LinkedMap[K, V]) LoadOrStore(key K, value V) (v V, exist bool) {
	e, exist := m.m[key]
	if exist {
		return e.value, true
	}
	m.push(m.newEntry(key, value))
	return value, false
}

// Replace 替换指定 key 的对应的值，如果不存在则不执行任何操作
func (m *LinkedMap[K, V]) Replace(key K, value V) bool {
	if e, exist := m.m[key]; exist {
		e.value = value
		return true
	}
	return false
}

// Push 向 LinkedMap 尾部添加指定键值对，如果存在则先移除旧的键值对。返回旧的键值对的值以及是否
// 存在
func (m *LinkedMap[K, V]) Push(key K, value V) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		m.remove(e)
	}
	m.push(m.newEntry(key, value))
	return
}

// Unshift 向 LinkedMap 头部添加指定键值对，如果存在则先移除旧的键值对。返回旧的键值对的值以及
// 是否存在
func (m *LinkedMap[K, V]) Unshift(key K, value V) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		m.remove(e)
	}
	m.unshift(m.newEntry(key, value))
	return
}

func (m *LinkedMap[K, V]) InsertBack(key K, value V, ref *LinkedMapEntry[K, V]) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		m.remove(e)
	}
	m.insert(m.newEntry(key, value), ref)
	return
}

func (m *LinkedMap[K, V]) InsertFront(key K, value V, ref *LinkedMapEntry[K, V]) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		m.remove(e)
	}
	m.insert(m.newEntry(key, value), ref.prev)
	return
}

func (m *LinkedMap[K, V]) Remove(key K) (old V, exist bool) {
	e, exist := m.m[key]
	if exist {
		old = e.value
		m.remove(e)
		return
	}
	return
}

func (m *LinkedMap[K, V]) RemoveEntry(e *LinkedMapEntry[K, V]) bool {
	if e.Removed() {
		return false
	}
	m.remove(e)
	return true
}

func (m *LinkedMap[K, V]) Delete(key K) {
	if e, exist := m.m[key]; exist {
		m.remove(e)
	}
}

func (m *LinkedMap[K, V]) LoadAndDelete(key K) (v V, exist bool) {
	e, exist := m.m[key]
	if exist {
		v = e.value
		m.remove(e)
	}
	return
}

func (m *LinkedMap[K, V]) Shift() (v V, exist bool) {
	if len(m.m) == 0 {
		return
	}
	e := m.head.next
	v, exist = e.value, true
	m.remove(e)
	return
}

func (m *LinkedMap[K, V]) ShiftKey() (k K, exist bool) {
	if len(m.m) == 0 {
		return
	}
	e := m.head.next
	k, exist = e.key, true
	m.remove(e)
	return
}

func (m *LinkedMap[K, V]) ShiftEntry() (e maps.Entry[K, V], exist bool) {
	if len(m.m) == 0 {
		return
	}
	entry := m.head.next
	e, exist = entry.Entry(), true
	m.remove(entry)
	return
}

func (m *LinkedMap[K, V]) Pop() (v V, exist bool) {
	if len(m.m) == 0 {
		return
	}
	e := m.tail.prev
	v, exist = e.value, true
	m.remove(e)
	return
}

func (m *LinkedMap[K, V]) PopKey() (k K, exist bool) {
	if len(m.m) == 0 {
		return
	}
	e := m.tail.prev
	k, exist = e.key, true
	m.remove(e)
	return
}

func (m *LinkedMap[K, V]) Clear() {
	for _, e := range m.entries {
		e.next, e.prev = nil, nil
	}
	for key := range m.m {
		delete(m.m, key)
	}
	m.entries = m.entries[:0]
	m.head.next = m.tail
	m.tail.prev = m.head
}