11375974525

Committed 17 Oct 2024 12:21AM UTC coverage: 57.867% (-0.9%) from 58.78%

Build # 11375974525

Build Type

Pull #9148

github

Committed by

ProofOfKeags

Commit Message

lnwire: convert DynPropose and DynCommit to use typed tlv records

Pull Request Pull Request #9148: DynComms [2/n]: lnwire: add authenticated wire messages for Dyn*

Run Details

336 of 477 new or added lines in 12 files covered. (70.44%)

18915 existing lines in 242 files now uncovered.

99181 of 171395 relevant lines covered (57.87%)

37360.97 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] {	5,963,713✔
47	if e.list == nil {	5,963,714✔
48	return nil	1✔
49	}	1✔
50
51	if e.next == &e.list.root {	6,020,284✔
52	return nil	56,572✔
53	}	56,572✔
54
55	return e.next	5,907,140✔
56	}
57
58	// Prev returns the previous list node or nil.
59	func (e Node[A]) Prev() Node[A] {	13,581✔
60	if e.list == nil {	13,582✔
61	return nil	1✔
62	}	1✔
63
64	if e.prev == &e.list.root {	13,712✔
65	return nil	132✔
66	}	132✔
67
68	return e.prev	13,448✔
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,151✔
86	l.root.next = &l.root	5,151✔
87	l.root.prev = &l.root	5,151✔
88	l.len = 0	5,151✔
89		5,151✔
90	return l	5,151✔
91	}	5,151✔
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() {	261,229✔
97	if l.root.next == nil {	261,237✔
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] {	288,821✔
104	// Make n point to correct neighborhood.	288,821✔
105	n.prev = predecessor	288,821✔
106	n.next = predecessor.next	288,821✔
107		288,821✔
108	// Make neighborhood point to n.	288,821✔
109	n.prev.next = n	288,821✔
110	n.next.prev = n	288,821✔
111		288,821✔
112	// Make n part of the list.	288,821✔
113	n.list = l	288,821✔
114		288,821✔
115	// Increment list length.	288,821✔
116	l.len++	288,821✔
117		288,821✔
118	return n	288,821✔
119	}	288,821✔
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] {	288,821✔
124	return l.insert(&Node[A]{Value: a}, predecessor)	288,821✔
125	}	288,821✔
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]) {	811✔
130	if n == predecessor {	818✔
131	return // Can't move after itself.	7✔
132	}	7✔
133
134	if predecessor.next == n {	816✔
135	return // Nothing to be done.	12✔
136	}	12✔
137
138	// Bind previous and next to each other.
139	n.prev.next = n.next	792✔
140	n.next.prev = n.prev	792✔
141		792✔
142	// Make n point to new neighborhood.	792✔
143	n.prev = predecessor	792✔
144	n.next = predecessor.next	792✔
145		792✔
146	// Make new neighborhood point to n.	792✔
147	n.prev.next = n	792✔
148	n.next.prev = n	792✔
149	}
150
151	// New returns an initialized List.
152	func NewList[A any]() *List[A] {	5,143✔
153	l := List[A]{}	5,143✔
154	return l.Init()	5,143✔
155	}	5,143✔
156
157	// Len returns the number of elements of List l.
158	// The complexity is O(1).
159	func (l *List[A]) Len() int {	57,648✔
160	return l.len	57,648✔
161	}	57,648✔
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] {	146,689✔
165	if l.len == 0 {	169,094✔
166	return nil	22,405✔
167	}	22,405✔
168
169	return l.root.next	124,284✔
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] {	231,902✔
174	if l.len == 0 {	231,903✔
175	return nil	1✔
176	}	1✔
177
178	return l.root.prev	231,901✔
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 {	9,533✔
185	if n.list == l {	19,064✔
186	n.prev.next = n.next	9,531✔
187	n.next.prev = n.prev	9,531✔
188	l.len--	9,531✔
189		9,531✔
190	v := n.Value	9,531✔
191	// Set all node data to nil to prevent dangling references.	9,531✔
192	*n = Node[A]{Value: v}	9,531✔
193		9,531✔
194	return v	9,531✔
195	}	9,531✔
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] {	98✔
203	l.lazyInit()	98✔
204	return l.insertVal(a, &l.root)	98✔
205	}	98✔
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] {	260,919✔
210	l.lazyInit()	260,919✔
211	return l.insertVal(a, l.root.prev)	260,919✔
212	}	260,919✔
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✔
UNCOV 219	return l.insertVal(a, &l.root)	×
UNCOV 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] {	203✔
233	if predecessor == nil {	203✔
234	return l.insertVal(a, l.root.prev)	×
235	}	×
236
237	if predecessor.list != l {	204✔
238	return nil	1✔
239	}	1✔
240
241	return l.insertVal(a, predecessor)	202✔
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]) {	203✔
248	if n.list == l {	406✔
249	l.move(n, &l.root)	203✔
250	}	203✔
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]) {	203✔
257	if n.list == l {	406✔
258	l.move(n, l.root.prev)	203✔
259	}	203✔
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]) {	204✔
266	if n.list == l && successor.list == l {	407✔
267	l.move(n, successor.prev)	203✔
268	}	203✔
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]) {	203✔
275	if n.list == l && predecessor.list == l {	405✔
276	l.move(n, predecessor)	202✔
277	}	202✔
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]) {	106✔
283	l.lazyInit()	106✔
284	n := other.Front()	106✔
285	sz := other.Len()	106✔
286	for i := 0; i < sz; i++ {	14,111✔
287	l.insertVal(n.Value, l.root.prev)	14,005✔
288	n = n.Next()	14,005✔
289	}	14,005✔
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]) {	106✔
295	l.lazyInit()	106✔
296	n := other.Back()	106✔
297	sz := other.Len()	106✔
298	for i := 0; i < sz; i++ {	13,499✔
299	l.insertVal(n.Value, &l.root)	13,393✔
300	n = n.Prev()	13,393✔
301	}	13,393✔
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() {	52,591✔
310	a := cursor.Value	52,191✔
311	if f(a) {	79,629✔
312	acc = append(acc, a)	27,438✔
313	}	27,438✔
314	}
315
316	return acc	400✔
317	}

lightningnetwork / lnd / 11375974525

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