10244606158

Committed 05 Aug 2024 07:33AM UTC coverage: 58.686% (+0.007%) from 58.679%

Build # 10244606158

Build Type

Pull #8959

github

Committed by

guggero

Commit Message

mod: bump kvdb to v1.4.10

To support the new comma-separated list of etcd hosts in db.etcd.host,
we need to bump the `kvdb` submodule version.
This also fixes a leader election bug in the etcd code.

Pull Request Pull Request #8959: mod: bump kvdb to v1.4.10

Run Details

125469 of 213798 relevant lines covered (58.69%)

28246.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.67

/fn/list.go

// Copyright (c) 2009 The Go Authors. All rights reserved.
// Copyright (c) 2024 Lightning Labs and the Lightning Network Developers

// 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.
package fn

type Node[A any] struct {
        // prev is a pointer to the previous node in the List.
        prev *Node[A]

        // next is a pointer to the next node in the List.
        next *Node[A]

        // list is the root pointer to the List in which this node is located.
        list *List[A]

        // Value is the actual data contained within the Node.
        Value A
}

// Next returns the next list node or nil.
func (e *Node[A]) Next() *Node[A] {
        if e.list == nil {
                return nil
        }

        if e.next == &e.list.root {
                return nil
        }

        return e.next
}

// Prev returns the previous list node or nil.
func (e *Node[A]) Prev() *Node[A] {
        if e.list == nil {
                return nil
        }

        if e.prev == &e.list.root {
                return nil
        }

        return e.prev
}

// List represents a doubly linked list.
// The zero value for List is an empty list ready to use.
type List[A any] struct {
        // root is a sentinal Node to identify the head and tail of the list.
        // root.prev is the tail, root.next is the head. For the purposes of
        // elegance, the absence of a next or prev node is encoded as the
        // address of the root node.
        root Node[A]

        // len is the current length of the list.
        len int
}

// Init intializes or clears the List l.
func (l *List[A]) Init() *List[A] {
        l.root.next = &l.root
        l.root.prev = &l.root
        l.len = 0

        return l
}

// lazyInit lazily initializes a zero List value. It is called by other public
// functions that could feasibly be called on a List that was initialized by the
// raw List[A]{} constructor.
func (l *List[A]) lazyInit() {
        if l.root.next == nil {
                l.Init()
        }
}

// insert inserts n after predecessor, increments l.len, and returns n.
func (l *List[A]) insert(n *Node[A], predecessor *Node[A]) *Node[A] {
        // Make n point to correct neighborhood.
        n.prev = predecessor
        n.next = predecessor.next

        // Make neighborhood point to n.
        n.prev.next = n
        n.next.prev = n

        // Make n part of the list.
        n.list = l

        // Increment list length.
        l.len++

        return n
}

// insertVal is a convenience wrapper for
// insert(&Node[A]{Value: v}, predecessor).
func (l *List[A]) insertVal(a A, predecessor *Node[A]) *Node[A] {
        return l.insert(&Node[A]{Value: a}, predecessor)
}

// move removes n from its current position and inserts it as the successor to
// predecessor.
func (l *List[A]) move(n *Node[A], predecessor *Node[A]) {
        if n == predecessor {
                return // Can't move after itself.
        }

        if predecessor.next == n {
                return // Nothing to be done.
        }

        // Bind previous and next to each other.
        n.prev.next = n.next
        n.next.prev = n.prev

        // Make n point to new neighborhood.
        n.prev = predecessor
        n.next = predecessor.next

        // Make new neighborhood point to n.
        n.prev.next = n
        n.next.prev = n
}

// New returns an initialized List.
func NewList[A any]() *List[A] {
        l := List[A]{}
        return l.Init()
}

// Len returns the number of elements of List l.
// The complexity is O(1).
func (l *List[A]) Len() int {
        return l.len
}

// Front returns the first Node of List l or nil if the list is empty.
func (l *List[A]) Front() *Node[A] {
        if l.len == 0 {
                return nil
        }

        return l.root.next
}

// Back returns the last Node of List l or nil if the list is empty.
func (l *List[A]) Back() *Node[A] {
        if l.len == 0 {
                return nil
        }

        return l.root.prev
}

// Remove removes Node n from List l if n is an element of List l.
// It returns the Node value e.Value.
// The Node must not be nil.
func (l *List[A]) Remove(n *Node[A]) A {
        if n.list == l {
                n.prev.next = n.next
                n.next.prev = n.prev
                l.len--

                v := n.Value
                // Set all node data to nil to prevent dangling references.
                *n = Node[A]{Value: v}

                return v
        }

        return n.Value
}

// PushFront inserts a new Node n with value a at the front of List l and
// returns n.
func (l *List[A]) PushFront(a A) *Node[A] {
        l.lazyInit()
        return l.insertVal(a, &l.root)
}

// PushBack inserts a new Node n with value a at the back of List l and returns
// n.
func (l *List[A]) PushBack(a A) *Node[A] {
        l.lazyInit()
        return l.insertVal(a, l.root.prev)
}

// InsertBefore inserts a new Node n with value a immediately before successor
// and returns n. If successor is not an element of l, the list is not
// modified. The successor must not be nil.
func (l *List[A]) InsertBefore(a A, successor *Node[A]) *Node[A] {
        if successor == nil {
                return l.insertVal(a, &l.root)
        }

        if successor.list != l {
                return nil
        }

        return l.insertVal(a, successor.prev)
}

// InsertAfter inserts a new Node n with value a immediately after  and returns
// e. If predecessor is not an element of l, the list is not modified. The
// predecessor must not be nil.
func (l *List[A]) InsertAfter(a A, predecessor *Node[A]) *Node[A] {
        if predecessor == nil {
                return l.insertVal(a, l.root.prev)
        }

        if predecessor.list != l {
                return nil
        }

        return l.insertVal(a, predecessor)
}

// MoveToFront moves Node n to the front of List l.
// If n is not an element of l, the list is not modified.
// The Node must not be nil.
func (l *List[A]) MoveToFront(n *Node[A]) {
        if n.list == l {
                l.move(n, &l.root)
        }
}

// MoveToBack moves Node n to the back of List l.
// If n is not an element of l, the list is not modified.
// The Node must not be nil.
func (l *List[A]) MoveToBack(n *Node[A]) {
        if n.list == l {
                l.move(n, l.root.prev)
        }
}

// MoveBefore moves Node n to its new position before successor.
// If n or successor is not an element of l, or n == successor, the list is not
// modified. The Node and successor must not be nil.
func (l *List[A]) MoveBefore(n, successor *Node[A]) {
        if n.list == l && successor.list == l {
                l.move(n, successor.prev)
        }
}

// MoveAfter moves Node n to its new position after predecessor.
// If n or predecessor is not an element of l, or n == predecessor, the list is
// not modified. The Node and predecessor must not be nil.
func (l *List[A]) MoveAfter(n, predecessor *Node[A]) {
        if n.list == l && predecessor.list == l {
                l.move(n, predecessor)
        }
}

// PushBackList inserts a copy of List other at the back of List l.
// The Lists l and other may be the same. They must not be nil.
func (l *List[A]) PushBackList(other *List[A]) {
        l.lazyInit()
        n := other.Front()
        sz := other.Len()
        for i := 0; i < sz; i++ {
                l.insertVal(n.Value, l.root.prev)
                n = n.Next()
        }
}

// PushFrontList inserts a copy of List other at the front of List l.
// The Lists l and other may be the same. They must not be nil.
func (l *List[A]) PushFrontList(other *List[A]) {
        l.lazyInit()
        n := other.Back()
        sz := other.Len()
        for i := 0; i < sz; i++ {
                l.insertVal(n.Value, &l.root)
                n = n.Prev()
        }
}

1	// Copyright (c) 2009 The Go Authors. All rights reserved.
2	// Copyright (c) 2024 Lightning Labs and the Lightning Network Developers
3
4	// Redistribution and use in source and binary forms, with or without
5	// modification, are permitted provided that the following conditions are
6	// met:
7
8	// * Redistributions of source code must retain the above copyright
9	// notice, this list of conditions and the following disclaimer.
10	// * Redistributions in binary form must reproduce the above
11	// copyright notice, this list of conditions and the following disclaimer
12	// in the documentation and/or other materials provided with the
13	// distribution.
14	// * Neither the name of Google Inc. nor the names of its
15	// contributors may be used to endorse or promote products derived from
16	// this software without specific prior written permission.
17
18	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29	package fn
30
31	type Node[A any] struct {
32	// prev is a pointer to the previous node in the List.
33	prev *Node[A]
34
35	// next is a pointer to the next node in the List.
36	next *Node[A]
37
38	// list is the root pointer to the List in which this node is located.
39	list *List[A]
40
41	// Value is the actual data contained within the Node.
42	Value A
43	}
44
45	// Next returns the next list node or nil.
46	func (e Node[A]) Next() Node[A] {	147,251✔
47	if e.list == nil {	147,252✔
48	return nil	1✔
49	}	1✔
50
51	if e.next == &e.list.root {	147,603✔
52	return nil	353✔
53	}	353✔
54
55	return e.next	146,897✔
56	}
57
58	// Prev returns the previous list node or nil.
59	func (e Node[A]) Prev() Node[A] {	13,342✔
60	if e.list == nil {	13,343✔
61	return nil	1✔
62	}	1✔
63
64	if e.prev == &e.list.root {	13,472✔
65	return nil	131✔
66	}	131✔
67
68	return e.prev	13,210✔
69	}
70
71	// List represents a doubly linked list.
72	// The zero value for List is an empty list ready to use.
73	type List[A any] struct {
74	// root is a sentinal Node to identify the head and tail of the list.
75	// root.prev is the tail, root.next is the head. For the purposes of
76	// elegance, the absence of a next or prev node is encoded as the
77	// address of the root node.
78	root Node[A]
79
80	// len is the current length of the list.
81	len int
82	}
83
84	// Init intializes or clears the List l.
85	func (l List[A]) Init() List[A] {	1,619✔
86	l.root.next = &l.root	1,619✔
87	l.root.prev = &l.root	1,619✔
88	l.len = 0	1,619✔
89		1,619✔
90	return l	1,619✔
91	}	1,619✔
92
93	// lazyInit lazily initializes a zero List value. It is called by other public
94	// functions that could feasibly be called on a List that was initialized by the
95	// raw List[A]{} constructor.
96	func (l *List[A]) lazyInit() {	200,977✔
97	if l.root.next == nil {	200,985✔
98	l.Init()	8✔
99	}	8✔
100	}
101
102	// insert inserts n after predecessor, increments l.len, and returns n.
103	func (l List[A]) insert(n Node[A], predecessor Node[A]) Node[A] {	227,075✔
104	// Make n point to correct neighborhood.	227,075✔
105	n.prev = predecessor	227,075✔
106	n.next = predecessor.next	227,075✔
107		227,075✔
108	// Make neighborhood point to n.	227,075✔
109	n.prev.next = n	227,075✔
110	n.next.prev = n	227,075✔
111		227,075✔
112	// Make n part of the list.	227,075✔
113	n.list = l	227,075✔
114		227,075✔
115	// Increment list length.	227,075✔
116	l.len++	227,075✔
117		227,075✔
118	return n	227,075✔
119	}	227,075✔
120
121	// insertVal is a convenience wrapper for
122	// insert(&Node[A]{Value: v}, predecessor).
123	func (l List[A]) insertVal(a A, predecessor Node[A]) *Node[A] {	227,075✔
124	return l.insert(&Node[A]{Value: a}, predecessor)	227,075✔
125	}	227,075✔
126
127	// move removes n from its current position and inserts it as the successor to
128	// predecessor.
129	func (l List[A]) move(n Node[A], predecessor *Node[A]) {	807✔
130	if n == predecessor {	816✔
131	return // Can't move after itself.	9✔
132	}	9✔
133
134	if predecessor.next == n {	805✔
135	return // Nothing to be done.	7✔
136	}	7✔
137
138	// Bind previous and next to each other.
139	n.prev.next = n.next	791✔
140	n.next.prev = n.prev	791✔
141		791✔
142	// Make n point to new neighborhood.	791✔
143	n.prev = predecessor	791✔
144	n.next = predecessor.next	791✔
145		791✔
146	// Make new neighborhood point to n.	791✔
147	n.prev.next = n	791✔
148	n.next.prev = n	791✔
149	}
150
151	// New returns an initialized List.
152	func NewList[A any]() *List[A] {	1,611✔
153	l := List[A]{}	1,611✔
154	return l.Init()	1,611✔
155	}	1,611✔
156
157	// Len returns the number of elements of List l.
158	// The complexity is O(1).
159	func (l *List[A]) Len() int {	54,517✔
160	return l.len	54,517✔
161	}	54,517✔
162
163	// Front returns the first Node of List l or nil if the list is empty.
164	func (l List[A]) Front() Node[A] {	1,975✔
165	if l.len == 0 {	1,977✔
166	return nil	2✔
167	}	2✔
168
169	return l.root.next	1,973✔
170	}
171
172	// Back returns the last Node of List l or nil if the list is empty.
173	func (l List[A]) Back() Node[A] {	652✔
174	if l.len == 0 {	653✔
175	return nil	1✔
176	}	1✔
177
178	return l.root.prev	651✔
179	}
180
181	// Remove removes Node n from List l if n is an element of List l.
182	// It returns the Node value e.Value.
183	// The Node must not be nil.
184	func (l List[A]) Remove(n Node[A]) A {	115✔
185	if n.list == l {	228✔
186	n.prev.next = n.next	113✔
187	n.next.prev = n.prev	113✔
188	l.len--	113✔
189		113✔
190	v := n.Value	113✔
191	// Set all node data to nil to prevent dangling references.	113✔
192	*n = Node[A]{Value: v}	113✔
193		113✔
194	return v	113✔
195	}	113✔
196
197	return n.Value	2✔
198	}
199
200	// PushFront inserts a new Node n with value a at the front of List l and
201	// returns n.
202	func (l List[A]) PushFront(a A) Node[A] {	115✔
203	l.lazyInit()	115✔
204	return l.insertVal(a, &l.root)	115✔
205	}	115✔
206
207	// PushBack inserts a new Node n with value a at the back of List l and returns
208	// n.
209	func (l List[A]) PushBack(a A) Node[A] {	200,652✔
210	l.lazyInit()	200,652✔
211	return l.insertVal(a, l.root.prev)	200,652✔
212	}	200,652✔
213
214	// InsertBefore inserts a new Node n with value a immediately before successor
215	// and returns n. If successor is not an element of l, the list is not
216	// modified. The successor must not be nil.
217	func (l List[A]) InsertBefore(a A, successor Node[A]) *Node[A] {	204✔
218	if successor == nil {	205✔
219	return l.insertVal(a, &l.root)	1✔
220	}	1✔
221
222	if successor.list != l {	204✔
223	return nil	1✔
224	}	1✔
225
226	return l.insertVal(a, successor.prev)	202✔
227	}
228
229	// InsertAfter inserts a new Node n with value a immediately after and returns
230	// e. If predecessor is not an element of l, the list is not modified. The
231	// predecessor must not be nil.
232	func (l List[A]) InsertAfter(a A, predecessor Node[A]) *Node[A] {	204✔
233	if predecessor == nil {	204✔
234	return l.insertVal(a, l.root.prev)	×
235	}	×
236
237	if predecessor.list != l {	205✔
238	return nil	1✔
239	}	1✔
240
241	return l.insertVal(a, predecessor)	203✔
242	}
243
244	// MoveToFront moves Node n to the front of List l.
245	// If n is not an element of l, the list is not modified.
246	// The Node must not be nil.
247	func (l List[A]) MoveToFront(n Node[A]) {	202✔
248	if n.list == l {	404✔
249	l.move(n, &l.root)	202✔
250	}	202✔
251	}
252
253	// MoveToBack moves Node n to the back of List l.
254	// If n is not an element of l, the list is not modified.
255	// The Node must not be nil.
256	func (l List[A]) MoveToBack(n Node[A]) {	202✔
257	if n.list == l {	404✔
258	l.move(n, l.root.prev)	202✔
259	}	202✔
260	}
261
262	// MoveBefore moves Node n to its new position before successor.
263	// If n or successor is not an element of l, or n == successor, the list is not
264	// modified. The Node and successor must not be nil.
265	func (l List[A]) MoveBefore(n, successor Node[A]) {	203✔
266	if n.list == l && successor.list == l {	405✔
267	l.move(n, successor.prev)	202✔
268	}	202✔
269	}
270
271	// MoveAfter moves Node n to its new position after predecessor.
272	// If n or predecessor is not an element of l, or n == predecessor, the list is
273	// not modified. The Node and predecessor must not be nil.
274	func (l List[A]) MoveAfter(n, predecessor Node[A]) {	202✔
275	if n.list == l && predecessor.list == l {	403✔
276	l.move(n, predecessor)	201✔
277	}	201✔
278	}
279
280	// PushBackList inserts a copy of List other at the back of List l.
281	// The Lists l and other may be the same. They must not be nil.
282	func (l List[A]) PushBackList(other List[A]) {	105✔
283	l.lazyInit()	105✔
284	n := other.Front()	105✔
285	sz := other.Len()	105✔
286	for i := 0; i < sz; i++ {	12,854✔
287	l.insertVal(n.Value, l.root.prev)	12,749✔
288	n = n.Next()	12,749✔
289	}	12,749✔
290	}
291
292	// PushFrontList inserts a copy of List other at the front of List l.
293	// The Lists l and other may be the same. They must not be nil.
294	func (l List[A]) PushFrontList(other List[A]) {	105✔
295	l.lazyInit()	105✔
296	n := other.Back()	105✔
297	sz := other.Len()	105✔
298	for i := 0; i < sz; i++ {	13,258✔
299	l.insertVal(n.Value, &l.root)	13,153✔
300	n = n.Prev()	13,153✔
301	}	13,153✔
302	}

lightningnetwork / lnd / 10244606158

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous