From 63fd74b1d568104ce9e91d865041008d67954771 Mon Sep 17 00:00:00 2001 From: conneroisu Date: Wed, 6 Nov 2024 14:20:06 -0600 Subject: [PATCH] removed doubly linked list dependency with own implementation --- go.mod | 1 - go.sum | 2 - pkg/list/doc.go | 2 + pkg/list/element.go | 35 +++++ pkg/list/list.go | 192 +++++++++++++++++++++++++++ pkg/list/list_test.go | 292 ++++++++++++++++++++++++++++++++++++++++++ pkg/omap/omap.go | 2 +- 7 files changed, 522 insertions(+), 4 deletions(-) create mode 100644 pkg/list/doc.go create mode 100644 pkg/list/element.go create mode 100644 pkg/list/list.go create mode 100644 pkg/list/list_test.go diff --git a/go.mod b/go.mod index 4a9194b..6270f73 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,6 @@ module github.com/conneroisu/groq-go go 1.23.2 require ( - github.com/bahlo/generic-list-go v0.2.0 github.com/buger/jsonparser v1.1.1 github.com/gorilla/websocket v1.5.3 github.com/stretchr/testify v1.9.0 diff --git a/go.sum b/go.sum index 6e460a3..c6c3137 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,3 @@ -github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk= -github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg= github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs= github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= diff --git a/pkg/list/doc.go b/pkg/list/doc.go new file mode 100644 index 0000000..15e3852 --- /dev/null +++ b/pkg/list/doc.go @@ -0,0 +1,2 @@ +// Package list containes the implementation a doubly linked list. +package list diff --git a/pkg/list/element.go b/pkg/list/element.go new file mode 100644 index 0000000..cdd6738 --- /dev/null +++ b/pkg/list/element.go @@ -0,0 +1,35 @@ +package list + +// Element is an element of a linked list. +type Element[T 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[T] + + // The list to which this element belongs. + list *List[T] + + // The value stored with this element. + Value T +} + +// Next returns the next list element or nil. +func (e *Element[T]) Next() *Element[T] { + p := e.next + if e.list != nil && p != &e.list.root { + return p + } + return nil +} + +// Prev returns the previous list element or nil. +func (e *Element[T]) Prev() *Element[T] { + p := e.prev + if e.list != nil && p != &e.list.root { + return p + } + return nil +} diff --git a/pkg/list/list.go b/pkg/list/list.go new file mode 100644 index 0000000..b78a5ca --- /dev/null +++ b/pkg/list/list.go @@ -0,0 +1,192 @@ +package list + +// List represents a doubly linked list. +// The zero value for List is an empty list ready to use. +type List[T any] struct { + root Element[T] // sentinel list element, only &root, root.prev, and root.next are used + len int // current list length excluding (this) sentinel element +} + +// Init initializes or clears list l. +func (l *List[T]) Init() *List[T] { + l.root.next = &l.root + l.root.prev = &l.root + l.len = 0 + return l +} + +// New returns an initialized list. +func New[T any]() *List[T] { return new(List[T]).Init() } + +// Len returns the number of elements of list l. +// The complexity is O(1). +func (l *List[T]) Len() int { return l.len } + +// Front returns the first element of list l or nil if the list is empty. +func (l *List[T]) Front() *Element[T] { + if l.len == 0 { + return nil + } + return l.root.next +} + +// Back returns the last element of list l or nil if the list is empty. +func (l *List[T]) Back() *Element[T] { + if l.len == 0 { + return nil + } + return l.root.prev +} + +// lazyInit lazily initializes a zero List value. +func (l *List[T]) lazyInit() { + if l.root.next == nil { + l.Init() + } +} + +// insert inserts e after at, increments l.len, and returns e. +func (l *List[T]) insert(e, at *Element[T]) *Element[T] { + e.prev = at + e.next = at.next + e.prev.next = e + e.next.prev = e + e.list = l + l.len++ + return e +} + +// insertValue is a convenience wrapper for insert(&Element{Value: v}, at). +func (l *List[T]) insertValue(v T, at *Element[T]) *Element[T] { + return l.insert(&Element[T]{Value: v}, at) +} + +// remove removes e from its list, decrements l.len +func (l *List[T]) remove(e *Element[T]) { + e.prev.next = e.next + e.next.prev = e.prev + e.next = nil // avoid memory leaks + e.prev = nil // avoid memory leaks + e.list = nil + l.len-- +} + +// move moves e to next to at. +func (l *List[T]) move(e, at *Element[T]) { + if e == at { + return + } + e.prev.next = e.next + e.next.prev = e.prev + + e.prev = at + e.next = at.next + e.prev.next = e + e.next.prev = e +} + +// Remove removes e from l if e is an element of list l. +// It returns the element value e.Value. +// The element must not be nil. +func (l *List[T]) Remove(e *Element[T]) T { + if e.list == l { + // if e.list == l, l must have been initialized when e was inserted + // in l or l == nil (e is a zero Element) and l.remove will crash + l.remove(e) + } + return e.Value +} + +// PushFront inserts a new element e with value v at the front of list l and returns e. +func (l *List[T]) PushFront(v T) *Element[T] { + l.lazyInit() + return l.insertValue(v, &l.root) +} + +// PushBack inserts a new element e with value v at the back of list l and returns e. +func (l *List[T]) PushBack(v T) *Element[T] { + l.lazyInit() + return l.insertValue(v, l.root.prev) +} + +// InsertBefore inserts a new element e with value v immediately before mark and returns e. +// If mark is not an element of l, the list is not modified. +// The mark must not be nil. +func (l *List[T]) InsertBefore(v T, mark *Element[T]) *Element[T] { + if mark.list != l { + return nil + } + // see comment in List.Remove about initialization of l + return l.insertValue(v, mark.prev) +} + +// InsertAfter inserts a new element e with value v immediately after mark and returns e. +// If mark is not an element of l, the list is not modified. +// The mark must not be nil. +func (l *List[T]) InsertAfter(v T, mark *Element[T]) *Element[T] { + if mark.list != l { + return nil + } + // see comment in List.Remove about initialization of l + return l.insertValue(v, mark) +} + +// MoveToFront moves element e to the front of list l. +// If e is not an element of l, the list is not modified. +// The element must not be nil. +func (l *List[T]) MoveToFront(e *Element[T]) { + if e.list != l || l.root.next == e { + return + } + // see comment in List.Remove about initialization of l + l.move(e, &l.root) +} + +// MoveToBack moves element e to the back of list l. +// If e is not an element of l, the list is not modified. +// The element must not be nil. +func (l *List[T]) MoveToBack(e *Element[T]) { + if e.list != l || l.root.prev == e { + return + } + // see comment in List.Remove about initialization of l + l.move(e, l.root.prev) +} + +// MoveBefore moves element e to its new position before mark. +// If e or mark is not an element of l, or e == mark, the list is not modified. +// The element and mark must not be nil. +func (l *List[T]) MoveBefore(e, mark *Element[T]) { + if e.list != l || e == mark || mark.list != l { + return + } + l.move(e, mark.prev) +} + +// MoveAfter moves element e to its new position after mark. +// If e or mark is not an element of l, or e == mark, the list is not modified. +// The element and mark must not be nil. +func (l *List[T]) MoveAfter(e, mark *Element[T]) { + if e.list != l || e == mark || mark.list != l { + return + } + l.move(e, mark) +} + +// PushBackList inserts a copy of another list at the back of list l. +// The lists l and other may be the same. They must not be nil. +func (l *List[T]) PushBackList(other *List[T]) { + l.lazyInit() + for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() { + l.insertValue(e.Value, l.root.prev) + } +} + +// PushFrontList inserts a copy of another list at the front of list l. +// The lists l and other may be the same. They must not be nil. +func (l *List[T]) PushFrontList(other *List[T]) { + l.lazyInit() + for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() { + l.insertValue(e.Value, &l.root) + } +} diff --git a/pkg/list/list_test.go b/pkg/list/list_test.go new file mode 100644 index 0000000..cd8ee3b --- /dev/null +++ b/pkg/list/list_test.go @@ -0,0 +1,292 @@ +package list + +import "testing" + +func checkListLen[T any](t *testing.T, l *List[T], len int) bool { + if n := l.Len(); n != len { + t.Errorf("l.Len() = %d, want %d", n, len) + return false + } + return true +} +func checkListPointers[T any](t *testing.T, l *List[T], es []*Element[T]) { + root := &l.root + if !checkListLen(t, l, len(es)) { + return + } + // zero length lists must be the zero value or properly initialized (sentinel circle) + if len(es) == 0 { + if l.root.next != nil && l.root.next != root || l.root.prev != nil && l.root.prev != root { + t.Errorf("l.root.next = %p, l.root.prev = %p; both should both be nil or %p", l.root.next, l.root.prev, root) + } + return + } + // len(es) > 0 + // check internal and external prev/next connections + for i, e := range es { + prev := root + Prev := (*Element[T])(nil) + if i > 0 { + prev = es[i-1] + Prev = prev + } + if p := e.prev; p != prev { + t.Errorf("elt[%d](%p).prev = %p, want %p", i, e, p, prev) + } + if p := e.Prev(); p != Prev { + t.Errorf("elt[%d](%p).Prev() = %p, want %p", i, e, p, Prev) + } + next := root + Next := (*Element[T])(nil) + if i < len(es)-1 { + next = es[i+1] + Next = next + } + if n := e.next; n != next { + t.Errorf("elt[%d](%p).next = %p, want %p", i, e, n, next) + } + if n := e.Next(); n != Next { + t.Errorf("elt[%d](%p).Next() = %p, want %p", i, e, n, Next) + } + } +} +func TestList(t *testing.T) { + // Single element list + { + l := New[string]() + checkListPointers(t, l, []*Element[string]{}) + e := l.PushFront("a") + checkListPointers(t, l, []*Element[string]{e}) + l.MoveToFront(e) + checkListPointers(t, l, []*Element[string]{e}) + l.MoveToBack(e) + checkListPointers(t, l, []*Element[string]{e}) + l.Remove(e) + checkListPointers(t, l, []*Element[string]{}) + } + // Bigger list + l := New[int]() + checkListPointers(t, l, []*Element[int]{}) + e2 := l.PushFront(2) + e1 := l.PushFront(1) + e3 := l.PushBack(3) + e4 := l.PushBack(4) + checkListPointers(t, l, []*Element[int]{e1, e2, e3, e4}) + l.Remove(e2) + checkListPointers(t, l, []*Element[int]{e1, e3, e4}) + l.MoveToFront(e3) // move from middle + checkListPointers(t, l, []*Element[int]{e3, e1, e4}) + l.MoveToFront(e1) + l.MoveToBack(e3) // move from middle + checkListPointers(t, l, []*Element[int]{e1, e4, e3}) + l.MoveToFront(e3) // move from back + checkListPointers(t, l, []*Element[int]{e3, e1, e4}) + l.MoveToFront(e3) // should be no-op + checkListPointers(t, l, []*Element[int]{e3, e1, e4}) + l.MoveToBack(e3) // move from front + checkListPointers(t, l, []*Element[int]{e1, e4, e3}) + l.MoveToBack(e3) // should be no-op + checkListPointers(t, l, []*Element[int]{e1, e4, e3}) + e2 = l.InsertBefore(2, e1) // insert before front + checkListPointers(t, l, []*Element[int]{e2, e1, e4, e3}) + l.Remove(e2) + e2 = l.InsertBefore(2, e4) // insert before middle + checkListPointers(t, l, []*Element[int]{e1, e2, e4, e3}) + l.Remove(e2) + e2 = l.InsertBefore(2, e3) // insert before back + checkListPointers(t, l, []*Element[int]{e1, e4, e2, e3}) + l.Remove(e2) + e2 = l.InsertAfter(2, e1) // insert after front + checkListPointers(t, l, []*Element[int]{e1, e2, e4, e3}) + l.Remove(e2) + e2 = l.InsertAfter(2, e4) // insert after middle + checkListPointers(t, l, []*Element[int]{e1, e4, e2, e3}) + l.Remove(e2) + e2 = l.InsertAfter(2, e3) // insert after back + checkListPointers(t, l, []*Element[int]{e1, e4, e3, e2}) + l.Remove(e2) + // Check standard iteration. + sum := 0 + for e := l.Front(); e != nil; e = e.Next() { + sum += e.Value + } + if sum != 8 { + t.Errorf("sum over l = %d, want 8", sum) + } + // Clear all elements by iterating + var next *Element[int] + for e := l.Front(); e != nil; e = next { + next = e.Next() + l.Remove(e) + } + checkListPointers(t, l, []*Element[int]{}) +} +func checkList[T int](t *testing.T, l *List[T], es []T) { + if !checkListLen(t, l, len(es)) { + return + } + i := 0 + for e := l.Front(); e != nil; e = e.Next() { + le := e.Value + if le != es[i] { + t.Errorf("elt[%d].Value = %v, want %v", i, le, es[i]) + } + i++ + } +} +func TestExtending(t *testing.T) { + l1 := New[int]() + l2 := New[int]() + l1.PushBack(1) + l1.PushBack(2) + l1.PushBack(3) + l2.PushBack(4) + l2.PushBack(5) + l3 := New[int]() + l3.PushBackList(l1) + checkList(t, l3, []int{1, 2, 3}) + l3.PushBackList(l2) + checkList(t, l3, []int{1, 2, 3, 4, 5}) + l3 = New[int]() + l3.PushFrontList(l2) + checkList(t, l3, []int{4, 5}) + l3.PushFrontList(l1) + checkList(t, l3, []int{1, 2, 3, 4, 5}) + checkList(t, l1, []int{1, 2, 3}) + checkList(t, l2, []int{4, 5}) + l3 = New[int]() + l3.PushBackList(l1) + checkList(t, l3, []int{1, 2, 3}) + l3.PushBackList(l3) + checkList(t, l3, []int{1, 2, 3, 1, 2, 3}) + l3 = New[int]() + l3.PushFrontList(l1) + checkList(t, l3, []int{1, 2, 3}) + l3.PushFrontList(l3) + checkList(t, l3, []int{1, 2, 3, 1, 2, 3}) + l3 = New[int]() + l1.PushBackList(l3) + checkList(t, l1, []int{1, 2, 3}) + l1.PushFrontList(l3) + checkList(t, l1, []int{1, 2, 3}) +} +func TestRemove(t *testing.T) { + l := New[int]() + e1 := l.PushBack(1) + e2 := l.PushBack(2) + checkListPointers(t, l, []*Element[int]{e1, e2}) + e := l.Front() + l.Remove(e) + checkListPointers(t, l, []*Element[int]{e2}) + l.Remove(e) + checkListPointers(t, l, []*Element[int]{e2}) +} +func TestIssue4103(t *testing.T) { + l1 := New[int]() + l1.PushBack(1) + l1.PushBack(2) + l2 := New[int]() + l2.PushBack(3) + l2.PushBack(4) + e := l1.Front() + l2.Remove(e) // l2 should not change because e is not an element of l2 + if n := l2.Len(); n != 2 { + t.Errorf("l2.Len() = %d, want 2", n) + } + l1.InsertBefore(8, e) + if n := l1.Len(); n != 3 { + t.Errorf("l1.Len() = %d, want 3", n) + } +} +func TestIssue6349(t *testing.T) { + l := New[int]() + l.PushBack(1) + l.PushBack(2) + e := l.Front() + l.Remove(e) + if e.Value != 1 { + t.Errorf("e.value = %d, want 1", e.Value) + } + if e.Next() != nil { + t.Errorf("e.Next() != nil") + } + if e.Prev() != nil { + t.Errorf("e.Prev() != nil") + } +} +func TestMove(t *testing.T) { + l := New[int]() + e1 := l.PushBack(1) + e2 := l.PushBack(2) + e3 := l.PushBack(3) + e4 := l.PushBack(4) + l.MoveAfter(e3, e3) + checkListPointers(t, l, []*Element[int]{e1, e2, e3, e4}) + l.MoveBefore(e2, e2) + checkListPointers(t, l, []*Element[int]{e1, e2, e3, e4}) + l.MoveAfter(e3, e2) + checkListPointers(t, l, []*Element[int]{e1, e2, e3, e4}) + l.MoveBefore(e2, e3) + checkListPointers(t, l, []*Element[int]{e1, e2, e3, e4}) + l.MoveBefore(e2, e4) + checkListPointers(t, l, []*Element[int]{e1, e3, e2, e4}) + e2, e3 = e3, e2 + l.MoveBefore(e4, e1) + checkListPointers(t, l, []*Element[int]{e4, e1, e2, e3}) + e1, e2, e3, e4 = e4, e1, e2, e3 + l.MoveAfter(e4, e1) + checkListPointers(t, l, []*Element[int]{e1, e4, e2, e3}) + e2, e3, e4 = e4, e2, e3 + l.MoveAfter(e2, e3) + checkListPointers(t, l, []*Element[int]{e1, e3, e2, e4}) +} + +// Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized List +func TestZeroList(t *testing.T) { + var l1 = new(List[int]) + l1.PushFront(1) + checkList(t, l1, []int{1}) + var l2 = new(List[int]) + l2.PushBack(1) + checkList(t, l2, []int{1}) + var l3 = new(List[int]) + l3.PushFrontList(l1) + checkList(t, l3, []int{1}) + var l4 = new(List[int]) + l4.PushBackList(l2) + checkList(t, l4, []int{1}) +} + +// Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l. +func TestInsertBeforeUnknownMark(t *testing.T) { + var l List[int] + l.PushBack(1) + l.PushBack(2) + l.PushBack(3) + l.InsertBefore(1, new(Element[int])) + checkList(t, &l, []int{1, 2, 3}) +} + +// Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l. +func TestInsertAfterUnknownMark(t *testing.T) { + var l List[int] + l.PushBack(1) + l.PushBack(2) + l.PushBack(3) + l.InsertAfter(1, new(Element[int])) + checkList(t, &l, []int{1, 2, 3}) +} + +// Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l. +func TestMoveUnknownMark(t *testing.T) { + var l1 List[int] + e1 := l1.PushBack(1) + var l2 List[int] + e2 := l2.PushBack(2) + l1.MoveAfter(e1, e2) + checkList(t, &l1, []int{1}) + checkList(t, &l2, []int{2}) + l1.MoveBefore(e1, e2) + checkList(t, &l1, []int{1}) + checkList(t, &l2, []int{2}) +} diff --git a/pkg/omap/omap.go b/pkg/omap/omap.go index a17c9eb..307e193 100644 --- a/pkg/omap/omap.go +++ b/pkg/omap/omap.go @@ -3,7 +3,7 @@ package omap import ( "fmt" - list "github.com/bahlo/generic-list-go" + "github.com/conneroisu/groq-go/pkg/list" ) // Pair is a generic pair.