31137380617

Committed 07 Aug 2026 01:14AM UTC coverage: 41.734% (-24.8%) from 66.574%

Build # 31137380617

Build Type

push

github

Committed by

sapslaj

Commit Message

fix: agent was getting re-installed every time

this _should_ help with that i hope

Coverage Stats

7 of 15 new or added lines in 1 file covered. (46.67%)

3299 existing lines in 30 files now uncovered.

5440 of 13035 relevant lines covered (41.73%)

211.19 hits per line

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

21.79

/pkg/syncmap/syncmap.go

// VERY slim wrapper around sync.Map with Go generics for that sweet sweet type safety
package syncmap

import (
        "iter"
        "sync"
)

type Map[K comparable, V any] struct {
        InnerMap     sync.Map
        DefaultValue V
}

func FromRegularMap[K comparable, V any](m map[K]V) *Map[K, V] {
        syncMap := Map[K, V]{}
        for key, value := range m {
                syncMap.Store(key, value)
        }
        return &syncMap
}

func (m *Map[K, V]) Clear() {
        m.InnerMap.Clear()
}

func (m *Map[K, V]) Delete(key K) {
        m.InnerMap.Delete(key)
}

func (m *Map[K, V]) Load(key K) (value V, loaded bool) {
        v, loaded := m.InnerMap.Load(key)
        value, ok := v.(V)
        if !ok {
                return m.DefaultValue, loaded
        }
        return
}

func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
        v, loaded := m.InnerMap.LoadAndDelete(key)
        value, ok := v.(V)
        if !ok {
                return m.DefaultValue, loaded
        }
        return
}

func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
        v, loaded := m.InnerMap.LoadOrStore(key, value)
        actual, ok := v.(V)
        if !ok {
                return m.DefaultValue, loaded
        }
        return
}

func (m *Map[K, V]) Range(f func(key K, value V) bool) {
        m.InnerMap.Range(func(key, value any) bool {
                return f(key.(K), value.(V))
        })
}

func (m *Map[K, V]) Items() iter.Seq2[K, V] {
        return func(yield func(K, V) bool) {
                m.Range(func(key K, value V) bool {
                        return yield(key, value)
                })
        }
}

func (m *Map[K, V]) Store(key K, value V) {
        m.InnerMap.Store(key, value)
}

func (m *Map[K, V]) Swap(key K, value V) (previous V, loaded bool) {
        v, loaded := m.InnerMap.Swap(key, value)
        previous, ok := v.(V)
        if !ok {
                return m.DefaultValue, loaded
        }
        return
}

func (m *Map[K, V]) ToRegularMap() map[K]V {
        newMap := map[K]V{}
        m.Range(func(key K, value V) bool {
                newMap[key] = value
                return true
        })
        return newMap
}

func (m *Map[K, V]) Length() int {
        l := 0
        m.Range(func(key K, value V) bool {
                l += 1
                return true
        })
        return l
}

type ComparableMap[K comparable, V comparable] struct {
        Map[K, V]
}

func ComparableFromRegularMap[K comparable, V comparable](m map[K]V) *ComparableMap[K, V] {
        syncMap := ComparableMap[K, V]{}
        for key, value := range m {
                syncMap.Store(key, value)
        }
        return &syncMap
}

func (m *ComparableMap[K, V]) CompareAndDelete(key K, old V) bool {
        return m.InnerMap.CompareAndDelete(key, old)
}

func (m *ComparableMap[K, V]) CompareAndSwap(key K, old V, new V) bool {
        return m.InnerMap.CompareAndSwap(key, old, new)
}

1	// VERY slim wrapper around sync.Map with Go generics for that sweet sweet type safety
2	package syncmap
3
4	import (
5	"iter"
6	"sync"
7	)
8
9	type Map[K comparable, V any] struct {
10	InnerMap sync.Map
11	DefaultValue V
12	}
13
14	func FromRegularMap[K comparable, V any](m map[K]V) *Map[K, V] {	×
15	syncMap := Map[K, V]{}	×
16	for key, value := range m {	×
17	syncMap.Store(key, value)	×
18	}	×
19	return &syncMap	×
20	}
21
22	func (m *Map[K, V]) Clear() {	×
23	m.InnerMap.Clear()	×
24	}	×
25
UNCOV 26	func (m *Map[K, V]) Delete(key K) {	×
UNCOV 27	m.InnerMap.Delete(key)	×
UNCOV 28	}	×
29
UNCOV 30	func (m *Map[K, V]) Load(key K) (value V, loaded bool) {	×
UNCOV 31	v, loaded := m.InnerMap.Load(key)	×
UNCOV 32	value, ok := v.(V)	×
UNCOV 33	if !ok {	×
34	return m.DefaultValue, loaded	×
35	}	×
UNCOV 36	return	×
37	}
38
39	func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool) {	×
40	v, loaded := m.InnerMap.LoadAndDelete(key)	×
41	value, ok := v.(V)	×
42	if !ok {	×
43	return m.DefaultValue, loaded	×
44	}	×
45	return	×
46	}
47
48	func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {	8✔
49	v, loaded := m.InnerMap.LoadOrStore(key, value)	8✔
50	actual, ok := v.(V)	8✔
51	if !ok {	8✔
52	return m.DefaultValue, loaded	×
53	}	×
54	return	8✔
55	}
56
57	func (m *Map[K, V]) Range(f func(key K, value V) bool) {	3✔
58	m.InnerMap.Range(func(key, value any) bool {	6✔
59	return f(key.(K), value.(V))	3✔
60	})	3✔
61	}
62
63	func (m *Map[K, V]) Items() iter.Seq2[K, V] {	3✔
64	return func(yield func(K, V) bool) {	6✔
65	m.Range(func(key K, value V) bool {	6✔
66	return yield(key, value)	3✔
67	})	3✔
68	}
69	}
70
71	func (m *Map[K, V]) Store(key K, value V) {	5✔
72	m.InnerMap.Store(key, value)	5✔
73	}	5✔
74
75	func (m *Map[K, V]) Swap(key K, value V) (previous V, loaded bool) {	×
76	v, loaded := m.InnerMap.Swap(key, value)	×
77	previous, ok := v.(V)	×
78	if !ok {	×
79	return m.DefaultValue, loaded	×
80	}	×
81	return	×
82	}
83
84	func (m *Map[K, V]) ToRegularMap() map[K]V {	×
85	newMap := map[K]V{}	×
86	m.Range(func(key K, value V) bool {	×
87	newMap[key] = value	×
88	return true	×
89	})	×
90	return newMap	×
91	}
92
93	func (m *Map[K, V]) Length() int {	×
94	l := 0	×
95	m.Range(func(key K, value V) bool {	×
96	l += 1	×
97	return true	×
98	})	×
99	return l	×
100	}
101
102	type ComparableMap[K comparable, V comparable] struct {
103	Map[K, V]
104	}
105
106	func ComparableFromRegularMap[K comparable, V comparable](m map[K]V) *ComparableMap[K, V] {	×
107	syncMap := ComparableMap[K, V]{}	×
108	for key, value := range m {	×
109	syncMap.Store(key, value)	×
110	}	×
111	return &syncMap	×
112	}
113
114	func (m *ComparableMap[K, V]) CompareAndDelete(key K, old V) bool {	×
115	return m.InnerMap.CompareAndDelete(key, old)	×
116	}	×
117
118	func (m *ComparableMap[K, V]) CompareAndSwap(key K, old V, new V) bool {	×
119	return m.InnerMap.CompareAndSwap(key, old, new)	×
120	}	×

sapslaj / mid / 31137380617

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