linkedmap.go

// Copyright 2025 bibenga
// Inspired by Apache Commons Collections (Apache License 2.0)
package linkedmap

import (
	"container/list"
	"iter"
	"orderedmap"
	"orderedmap/internal/utils"
)

type linkedMapEntry[K comparable, V any] struct {
	Key   K
	Value V
}

type LinkedMap[K comparable, V any] struct {
	data map[K]*list.Element
	list *list.List
}

var _ orderedmap.Map[int, int] = &LinkedMap[int, int]{}

func New[K comparable, V any](size int) *LinkedMap[K, V] {
	m := LinkedMap[K, V]{
		list: list.New(),
	}
	if size > 0 {
		m.data = make(map[K]*list.Element, size)
	} else {
		m.data = make(map[K]*list.Element)
	}
	return &m
}

func NewDefault[K comparable, V any]() orderedmap.Map[K, V] {
	return New[K, V](0)
}

func (m *LinkedMap[K, V]) Size() int {
	return len(m.data)
}

func (m *LinkedMap[K, V]) IsEmpty() bool {
	return len(m.data) == 0
}

func (m *LinkedMap[K, V]) Clear() {
	clear(m.data)
	m.list.Init()
}

func (m *LinkedMap[K, V]) Clone() orderedmap.Map[K, V] {
	cloned := New[K, V](len(m.data))
	for k, v := range m.Items() {
		cloned.Put(k, v)
	}
	return cloned
}

func (m *LinkedMap[K, V]) Put(key K, value V) (V, bool) {
	if e, ok := m.data[key]; ok {
		lme := e.Value.(linkedMapEntry[K, V])
		oldValue := lme.Value
		lme.Value = value
		e.Value = lme
		return oldValue, true
	} else {
		lme := linkedMapEntry[K, V]{Key: key, Value: value}
		e = m.list.PushBack(lme)
		m.data[key] = e
		var empty V
		return empty, false
	}
}

func (m *LinkedMap[K, V]) ContainsKey(key K) bool {
	_, found := m.data[key]
	return found
}

func (m *LinkedMap[K, V]) Get(key K) (V, bool) {
	if e, ok := m.data[key]; ok {
		lme := e.Value.(linkedMapEntry[K, V])
		return lme.Value, true
	} else {
		var empty V
		return empty, false
	}
}

func (m *LinkedMap[K, V]) Delete(key K) (V, bool) {
	var empty V
	if e, ok := m.data[key]; ok {
		lme := e.Value.(linkedMapEntry[K, V])
		value := lme.Value
		lme.Value = empty
		m.list.Remove(e)
		delete(m.data, key)
		return value, true
	} else {
		return empty, false
	}
}

func (m *LinkedMap[K, V]) Keys() iter.Seq[K] {
	return func(yield func(K) bool) {
		for e := m.list.Front(); e != nil; e = e.Next() {
			lme := e.Value.(linkedMapEntry[K, V])
			if !yield(lme.Key) {
				return
			}
		}
	}
}

func (m *LinkedMap[K, V]) Values() iter.Seq[V] {
	return func(yield func(V) bool) {
		for e := m.list.Front(); e != nil; e = e.Next() {
			lme := e.Value.(linkedMapEntry[K, V])
			if !yield(lme.Value) {
				return
			}
		}
	}
}

func (m *LinkedMap[K, V]) Items() iter.Seq2[K, V] {
	return func(yield func(K, V) bool) {
		for e := m.list.Front(); e != nil; e = e.Next() {
			lme := e.Value.(linkedMapEntry[K, V])
			if !yield(lme.Key, lme.Value) {
				return
			}
		}
	}
}

func (m *LinkedMap[K, V]) String() string {
	return utils.MapToString("LinkedMap", m)
}