pax_global_header00006660000000000000000000000064142004343440014510gustar00rootroot0000000000000052 comment=89fb9b4cdfd4b5295651f72e9f892f1595b4d6c9 generic-list-go-0.2.0/000077500000000000000000000000001420043434400144775ustar00rootroot00000000000000generic-list-go-0.2.0/.github/000077500000000000000000000000001420043434400160375ustar00rootroot00000000000000generic-list-go-0.2.0/.github/workflows/000077500000000000000000000000001420043434400200745ustar00rootroot00000000000000generic-list-go-0.2.0/.github/workflows/ci.yml000066400000000000000000000005141420043434400212120ustar00rootroot00000000000000name: CI on: pull_request: branches: - main push: branches: - main jobs: test: name: Test runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - uses: actions/setup-go@v2 with: go-version: v1.18.0-beta2 stable: false - run: go test -v ./... generic-list-go-0.2.0/LICENSE000066400000000000000000000027071420043434400155120ustar00rootroot00000000000000Copyright (c) 2009 The Go Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. generic-list-go-0.2.0/README.md000066400000000000000000000004561420043434400157630ustar00rootroot00000000000000# generic-list-go [![CI](https://github.com/bahlo/generic-list-go/actions/workflows/ci.yml/badge.svg)](https://github.com/bahlo/generic-list-go/actions/workflows/ci.yml) Go [container/list](https://pkg.go.dev/container/list) but with generics. The code is based on `container/list` in `go1.18beta2`. generic-list-go-0.2.0/example_test.go000066400000000000000000000011021420043434400175120ustar00rootroot00000000000000// Copyright 2013 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package list_test import ( "fmt" list "github.com/bahlo/generic-list-go" ) func Example() { // Create a new list and put some numbers in it. l := list.New[int]() e4 := l.PushBack(4) e1 := l.PushFront(1) l.InsertBefore(3, e4) l.InsertAfter(2, e1) // Iterate through list and print its contents. for e := l.Front(); e != nil; e = e.Next() { fmt.Println(e.Value) } // Output: // 1 // 2 // 3 // 4 } generic-list-go-0.2.0/go.mod000066400000000000000000000000611420043434400156020ustar00rootroot00000000000000module github.com/bahlo/generic-list-go go 1.18 generic-list-go-0.2.0/list.go000066400000000000000000000147021420043434400160050ustar00rootroot00000000000000// Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package list implements a doubly linked list. // // To iterate over a list (where l is a *List): // for e := l.Front(); e != nil; e = e.Next() { // // do something with e.Value // } // 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] { if p := e.next; 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] { if p := e.prev; e.list != nil && p != &e.list.root { return p } return nil } // 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) } } generic-list-go-0.2.0/list_test.go000066400000000000000000000200631420043434400170410ustar00rootroot00000000000000// Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. 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}) }