12203473065

Committed 06 Dec 2024 05:40PM UTC coverage: 58.983% (+0.01%) from 58.972%

Build # 12203473065

Build Type

Pull #9313

github

Committed by

aakselrod

Commit Message

temp: debug commit

Pull Request Pull Request #9313: Reapply 8644 on 9260

Run Details

36 of 72 new or added lines in 6 files covered. (50.0%)

55 existing lines in 18 files now uncovered.

134181 of 227492 relevant lines covered (58.98%)

19381.14 hits per line

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

97.48

/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()
        }
}

// Filter gives a slice of all of the node values that satisfy the given
// predicate.
func (l *List[A]) Filter(f Pred[A]) []A {
        var acc []A

        for cursor := l.Front(); cursor != nil; cursor = cursor.Next() {
                a := cursor.Value
                if f(a) {
                        acc = append(acc, a)
                }
        }

        return acc
}

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] {	361,945✔
47	if e.list == nil {	361,946✔
48	return nil	1✔
49	}	1✔
50
51	if e.next == &e.list.root {	391,464✔
52	return nil	29,520✔
53	}	29,520✔
54
55	return e.next	332,424✔
56	}
57
58	// Prev returns the previous list node or nil.
59	func (e Node[A]) Prev() Node[A] {	11,885✔
60	if e.list == nil {	11,886✔
61	return nil	1✔
62	}	1✔
63
64	if e.prev == &e.list.root {	12,015✔
65	return nil	131✔
66	}	131✔
67
68	return e.prev	11,753✔
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] {	5,173✔
86	l.root.next = &l.root	5,173✔
87	l.root.prev = &l.root	5,173✔
88	l.len = 0	5,173✔
89		5,173✔
90	return l	5,173✔
91	}	5,173✔
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() {	254,908✔
97	if l.root.next == nil {	254,916✔
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] {	279,984✔
104	// Make n point to correct neighborhood.	279,984✔
105	n.prev = predecessor	279,984✔
106	n.next = predecessor.next	279,984✔
107		279,984✔
108	// Make neighborhood point to n.	279,984✔
109	n.prev.next = n	279,984✔
110	n.next.prev = n	279,984✔
111		279,984✔
112	// Make n part of the list.	279,984✔
113	n.list = l	279,984✔
114		279,984✔
115	// Increment list length.	279,984✔
116	l.len++	279,984✔
117		279,984✔
118	return n	279,984✔
119	}	279,984✔
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] {	279,984✔
124	return l.insert(&Node[A]{Value: a}, predecessor)	279,984✔
125	}	279,984✔
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]) {	803✔
130	if n == predecessor {	813✔
131	return // Can't move after itself.	10✔
132	}	10✔
133
134	if predecessor.next == n {	803✔
135	return // Nothing to be done.	10✔
136	}	10✔
137
138	// Bind previous and next to each other.
139	n.prev.next = n.next	783✔
140	n.next.prev = n.prev	783✔
141		783✔
142	// Make n point to new neighborhood.	783✔
143	n.prev = predecessor	783✔
144	n.next = predecessor.next	783✔
145		783✔
146	// Make new neighborhood point to n.	783✔
147	n.prev.next = n	783✔
148	n.next.prev = n	783✔
149	}
150
151	// New returns an initialized List.
152	func NewList[A any]() *List[A] {	5,165✔
153	l := List[A]{}	5,165✔
154	return l.Init()	5,165✔
155	}	5,165✔
156
157	// Len returns the number of elements of List l.
158	// The complexity is O(1).
159	func (l *List[A]) Len() int {	52,603✔
160	return l.len	52,603✔
161	}	52,603✔
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] {	87,149✔
165	if l.len == 0 {	102,182✔
166	return nil	15,033✔
167	}	15,033✔
168
169	return l.root.next	72,116✔
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] {	140,114✔
174	if l.len == 0 {	140,115✔
175	return nil	1✔
176	}	1✔
177
178	return l.root.prev	140,113✔
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 {	5,566✔
185	if n.list == l {	11,130✔
186	n.prev.next = n.next	5,564✔
187	n.next.prev = n.prev	5,564✔
188	l.len--	5,564✔
189		5,564✔
190	v := n.Value	5,564✔
191	// Set all node data to nil to prevent dangling references.	5,564✔
192	*n = Node[A]{Value: v}	5,564✔
193		5,564✔
194	return v	5,564✔
195	}	5,564✔
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] {	112✔
203	l.lazyInit()	112✔
204	return l.insertVal(a, &l.root)	112✔
205	}	112✔
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] {	254,586✔
210	l.lazyInit()	254,586✔
211	return l.insertVal(a, l.root.prev)	254,586✔
212	}	254,586✔
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] {	205✔
218	if successor == nil {	205✔
219	return l.insertVal(a, &l.root)	×
220	}	×
221
222	if successor.list != l {	206✔
223	return nil	1✔
224	}	1✔
225
226	return l.insertVal(a, successor.prev)	204✔
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✔
UNCOV 234	return l.insertVal(a, l.root.prev)	×
UNCOV 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]) {	201✔
248	if n.list == l {	402✔
249	l.move(n, &l.root)	201✔
250	}	201✔
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]) {	201✔
257	if n.list == l {	402✔
258	l.move(n, l.root.prev)	201✔
259	}	201✔
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]) {	201✔
266	if n.list == l && successor.list == l {	401✔
267	l.move(n, successor.prev)	200✔
268	}	200✔
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++ {	13,288✔
287	l.insertVal(n.Value, l.root.prev)	13,183✔
288	n = n.Next()	13,183✔
289	}	13,183✔
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++ {	11,801✔
299	l.insertVal(n.Value, &l.root)	11,696✔
300	n = n.Prev()	11,696✔
301	}	11,696✔
302	}
303
304	// Filter gives a slice of all of the node values that satisfy the given
305	// predicate.
306	func (l *List[A]) Filter(f Pred[A]) []A {	400✔
307	var acc []A	400✔
308		400✔
309	for cursor := l.Front(); cursor != nil; cursor = cursor.Next() {	50,400✔
310	a := cursor.Value	50,000✔
311	if f(a) {	76,750✔
312	acc = append(acc, a)	26,750✔
313	}	26,750✔
314	}
315
316	return acc	400✔
317	}

lightningnetwork / lnd / 12203473065

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