11136034567

Committed 02 Oct 2024 01:06AM UTC coverage: 58.817% (+0.003%) from 58.814%

Build # 11136034567

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #8644 from Roasbeef/remove-sql-mutex-part-deux

kvdb/postgres: remove global application level lock

Run Details

130416 of 221731 relevant lines covered (58.82%)

28306.61 hits per line

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

97.33

/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,783,006✔
47	if e.list == nil {	5,783,007✔
48	return nil	1✔
49	}	1✔
50
51	if e.next == &e.list.root {	5,839,562✔
52	return nil	56,557✔
53	}	56,557✔
54
55	return e.next	5,726,448✔
56	}
57
58	// Prev returns the previous list node or nil.
59	func (e Node[A]) Prev() Node[A] {	12,786✔
60	if e.list == nil {	12,787✔
61	return nil	1✔
62	}	1✔
63
64	if e.prev == &e.list.root {	12,914✔
65	return nil	129✔
66	}	129✔
67
68	return e.prev	12,656✔
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] {	4,837✔
86	l.root.next = &l.root	4,837✔
87	l.root.prev = &l.root	4,837✔
88	l.len = 0	4,837✔
89		4,837✔
90	return l	4,837✔
91	}	4,837✔
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() {	215,880✔
97	if l.root.next == nil {	215,888✔
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] {	240,332✔
104	// Make n point to correct neighborhood.	240,332✔
105	n.prev = predecessor	240,332✔
106	n.next = predecessor.next	240,332✔
107		240,332✔
108	// Make neighborhood point to n.	240,332✔
109	n.prev.next = n	240,332✔
110	n.next.prev = n	240,332✔
111		240,332✔
112	// Make n part of the list.	240,332✔
113	n.list = l	240,332✔
114		240,332✔
115	// Increment list length.	240,332✔
116	l.len++	240,332✔
117		240,332✔
118	return n	240,332✔
119	}	240,332✔
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] {	240,332✔
124	return l.insert(&Node[A]{Value: a}, predecessor)	240,332✔
125	}	240,332✔
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]) {	804✔
130	if n == predecessor {	810✔
131	return // Can't move after itself.	6✔
132	}	6✔
133
134	if predecessor.next == n {	806✔
135	return // Nothing to be done.	8✔
136	}	8✔
137
138	// Bind previous and next to each other.
139	n.prev.next = n.next	790✔
140	n.next.prev = n.prev	790✔
141		790✔
142	// Make n point to new neighborhood.	790✔
143	n.prev = predecessor	790✔
144	n.next = predecessor.next	790✔
145		790✔
146	// Make new neighborhood point to n.	790✔
147	n.prev.next = n	790✔
148	n.next.prev = n	790✔
149	}
150
151	// New returns an initialized List.
152	func NewList[A any]() *List[A] {	4,829✔
153	l := List[A]{}	4,829✔
154	return l.Init()	4,829✔
155	}	4,829✔
156
157	// Len returns the number of elements of List l.
158	// The complexity is O(1).
159	func (l *List[A]) Len() int {	51,249✔
160	return l.len	51,249✔
161	}	51,249✔
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] {	144,524✔
165	if l.len == 0 {	166,014✔
166	return nil	21,490✔
167	}	21,490✔
168
169	return l.root.next	123,034✔
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] {	228,394✔
174	if l.len == 0 {	228,395✔
175	return nil	1✔
176	}	1✔
177
178	return l.root.prev	228,393✔
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,409✔
185	if n.list == l {	18,816✔
186	n.prev.next = n.next	9,407✔
187	n.next.prev = n.prev	9,407✔
188	l.len--	9,407✔
189		9,407✔
190	v := n.Value	9,407✔
191	// Set all node data to nil to prevent dangling references.	9,407✔
192	*n = Node[A]{Value: v}	9,407✔
193		9,407✔
194	return v	9,407✔
195	}	9,407✔
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] {	104✔
203	l.lazyInit()	104✔
204	return l.insertVal(a, &l.root)	104✔
205	}	104✔
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] {	215,570✔
210	l.lazyInit()	215,570✔
211	return l.insertVal(a, l.root.prev)	215,570✔
212	}	215,570✔
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✔
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]) {	200✔
257	if n.list == l {	400✔
258	l.move(n, l.root.prev)	200✔
259	}	200✔
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]) {	202✔
266	if n.list == l && successor.list == l {	403✔
267	l.move(n, successor.prev)	201✔
268	}	201✔
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]) {	103✔
283	l.lazyInit()	103✔
284	n := other.Front()	103✔
285	sz := other.Len()	103✔
286	for i := 0; i < sz; i++ {	11,757✔
287	l.insertVal(n.Value, l.root.prev)	11,654✔
288	n = n.Next()	11,654✔
289	}	11,654✔
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]) {	103✔
295	l.lazyInit()	103✔
296	n := other.Back()	103✔
297	sz := other.Len()	103✔
298	for i := 0; i < sz; i++ {	12,700✔
299	l.insertVal(n.Value, &l.root)	12,597✔
300	n = n.Prev()	12,597✔
301	}	12,597✔
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 {
307	var acc []A
308
309	for cursor := l.Front(); cursor != nil; cursor = cursor.Next() {
310	a := cursor.Value
311	if f(a) {
312	acc = append(acc, a)
313	}
314	}
315
316	return acc
317	}

lightningnetwork / lnd / 11136034567

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