Try to improve performances

v2/list.go

@@ -0,0 +1,95 @@
+package orderedmap
+
+// Element is an element of a null terminated (non circular) intrusive doubly linked list that contains the key of the correspondent element in the ordered map too.
+type Element[K comparable, V any] struct {
+ // Next and previous pointers in the doubly-linked list of elements.
+ // To simplify the implementation, internally a list l is implemented
+ // as a ring, such that &l.root is both the next element of the last
+ // list element (l.Back()) and the previous element of the first list
+ // element (l.Front()).
+ next, prev *Element[K, V]
+
+ // The key that corresponds to this element in the ordered map.
+ Key K
+
+ // The value stored with this element.
+ Value V
+}
+
+// Next returns the next list element or nil.
+func (e *Element[K, V]) Next() *Element[K, V] {
+ return e.next
+}
+
+// Prev returns the previous list element or nil.
+func (e *Element[K, V]) Prev() *Element[K, V] {
+ return e.prev
+}
+
+// list represents a null terminated (non circular) intrusive doubly linked list.
+// The list is immediately usable after instantiation without the need of a dedicated initialization.
+type list[K comparable, V any] struct {
+ root Element[K, V] // list head and tail
+}
+
+func (l *list[K, V]) IsEmpty() bool {
+ return l.root.next == nil
+}
+
+// Front returns the first element of list l or nil if the list is empty.
+func (l *list[K, V]) Front() *Element[K, V] {
+ return l.root.next
+}
+
+// Back returns the last element of list l or nil if the list is empty.
+func (l *list[K, V]) Back() *Element[K, V] {
+ return l.root.prev
+}
+
+// Remove removes e from its list
+func (l *list[K, V]) Remove(e *Element[K, V]) {
+ if e.prev == nil {
+ l.root.next = e.next
+ } else {
+ e.prev.next = e.next
+ }
+ if e.next == nil {
+ l.root.prev = e.prev
+ } else {
+ e.next.prev = e.prev
+ }
+ e.next = nil // avoid memory leaks
+ e.prev = nil // avoid memory leaks
+}
+
+// PushFront inserts a new element e with value v at the front of list l and returns e.
+func (l *list[K, V]) PushFront(key K, value V) *Element[K, V] {
+ e := &Element[K, V]{Key: key, Value: value}
+ if l.root.next == nil {
+ // It's the first element
+ l.root.next = e
+ l.root.prev = e
+ return e
+ }
+
+ e.next = l.root.next
+ l.root.next.prev = e
+ l.root.next = e
+ return e
+}
+
+// PushBack inserts a new element e with value v at the back of list l and returns e.
+func (l *list[K, V]) PushBack(key K, value V) *Element[K, V] {
+ e := &Element[K, V]{Key: key, Value: value}
+ if l.root.prev == nil {
+ // It's the first element
+ l.root.next = e
+ l.root.prev = e
+ return e
+ }
+
+ e.prev = l.root.prev
+ l.root.prev.next = e
+ l.root.prev = e
+ return e
+}

v2/orderedmap.go

@@ -1,23 +1,13 @@
 package orderedmap
 
-import (
- "container/list"
-)
-
-type orderedMapElement[K comparable, V any] struct {
- key K
- value V
-}
-
 type OrderedMap[K comparable, V any] struct {
- kv map[K]*list.Element
- ll *list.List
+ kv map[K]*Element[K, V]
+ ll list[K, V]
 }
 
 func NewOrderedMap[K comparable, V any]() *OrderedMap[K, V] {
  return &OrderedMap[K, V]{
- kv: make(map[K]*list.Element),
- ll: list.New(),
+ kv: make(map[K]*Element[K, V]),
  }
 }
 
@@ -26,7 +16,7 @@ func NewOrderedMap[K comparable, V any]() *OrderedMap[K, V] {
 func (m *OrderedMap[K, V]) Get(key K) (value V, ok bool) {
  v, ok := m.kv[key]
  if ok {
- value = v.Value.(*orderedMapElement[K, V]).value
+ value = v.Value
  }
 
  return
@@ -36,23 +26,22 @@ func (m *OrderedMap[K, V]) Get(key K) (value V, ok bool) {
 // will be returned. The returned value will be false if the value was replaced
 // (even if the value was the same).
 func (m *OrderedMap[K, V]) Set(key K, value V) bool {
- _, didExist := m.kv[key]
-
- if !didExist {
- element := m.ll.PushBack(&orderedMapElement[K, V]{key, value})
- m.kv[key] = element
- } else {
- m.kv[key].Value.(*orderedMapElement[K, V]).value = value
+ _, alreadyExist := m.kv[key]
+ if alreadyExist {
+ m.kv[key].Value = value
+ return false
  }
 
- return !didExist
+ element := m.ll.PushBack(key, value)
+ m.kv[key] = element
+ return true
 }
 
 // GetOrDefault returns the value for a key. If the key does not exist, returns
 // the default value instead.
 func (m *OrderedMap[K, V]) GetOrDefault(key K, defaultValue V) V {
  if value, ok := m.kv[key]; ok {
- return value.Value.(*orderedMapElement[K, V]).value
+ return value.Value
  }
 
  return defaultValue
@@ -61,14 +50,9 @@ func (m *OrderedMap[K, V]) GetOrDefault(key K, defaultValue V) V {
 // GetElement returns the element for a key. If the key does not exist, the
 // pointer will be nil.
 func (m *OrderedMap[K, V]) GetElement(key K) *Element[K, V] {
- value, ok := m.kv[key]
+ element, ok := m.kv[key]
  if ok {
- element := value.Value.(*orderedMapElement[K, V])
- return &Element[K, V]{
- element: value,
- Key: element.key,
- Value: element.value,
- }
+ return element
  }
 
  return nil
@@ -83,14 +67,10 @@ func (m *OrderedMap[K, V]) Len() int {
 // replaced it will retain the same position. To ensure most recently set keys
 // are always at the end you must always Delete before Set.
 func (m *OrderedMap[K, V]) Keys() (keys []K) {
- keys = make([]K, m.Len())
-
- element := m.ll.Front()
- for i := 0; element != nil; i++ {
- keys[i] = element.Value.(*orderedMapElement[K, V]).key
- element = element.Next()
+ keys = make([]K, 0, m.Len())
+ for el := m.Front(); el != nil; el = el.Next() {
+ keys = append(keys, el.Key)
  }
-
  return keys
 }
 
@@ -109,45 +89,21 @@ func (m *OrderedMap[K, V]) Delete(key K) (didDelete bool) {
 // Front will return the element that is the first (oldest Set element). If
 // there are no elements this will return nil.
 func (m *OrderedMap[K, V]) Front() *Element[K, V] {
- front := m.ll.Front()
- if front == nil {
- return nil
- }
-
- element := front.Value.(*orderedMapElement[K, V])
-
- return &Element[K, V]{
- element: front,
- Key: element.key,
- Value: element.value,
- }
+ return m.ll.Front()
 }
 
 // Back will return the element that is the last (most recent Set element). If
 // there are no elements this will return nil.
 func (m *OrderedMap[K, V]) Back() *Element[K, V] {
- back := m.ll.Back()
- if back == nil {
- return nil
- }
-
- element := back.Value.(*orderedMapElement[K, V])
-
- return &Element[K, V]{
- element: back,
- Key: element.key,
- Value: element.value,
- }
+ return m.ll.Back()
 }
 
 // Copy returns a new OrderedMap with the same elements.
 // Using Copy while there are concurrent writes may mangle the result.
 func (m *OrderedMap[K, V]) Copy() *OrderedMap[K, V] {
  m2 := NewOrderedMap[K, V]()
-
  for el := m.Front(); el != nil; el = el.Next() {
  m2.Set(el.Key, el.Value)
  }
-
  return m2
 }