13091498612

Committed 01 Feb 2025 06:55PM UTC coverage: 62.649% (+3.5%) from 59.117%

Build # 13091498612

Build Type

Pull #5431

github

Committed by

web-flow

Commit Message

remove unneeded comment

Pull Request Pull Request #5431: Add new callback-based settings listener API

Run Details

21 of 51 new or added lines in 6 files covered. (41.18%)

686 existing lines in 30 files now uncovered.

24905 of 39753 relevant lines covered (62.65%)

839.75 hits per line

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

88.89

/data/binding/generic.go

package binding

import (
        "sync/atomic"

        "fyne.io/fyne/v2"
)

func newBaseItem[T any](comparator func(T, T) bool) *baseItem[T] {
        return &baseItem[T]{val: new(T), comparator: comparator}
}

func newBaseItemComparable[T bool | float64 | int | rune | string]() *baseItem[T] {
        return newBaseItem[T](func(a, b T) bool { return a == b })
}

type baseItem[T any] struct {
        base

        comparator func(T, T) bool
        val        *T
}

func (b *baseItem[T]) Get() (T, error) {
        b.lock.RLock()
        defer b.lock.RUnlock()

        if b.val == nil {
                return *new(T), nil
        }
        return *b.val, nil
}

func (b *baseItem[T]) Set(val T) error {
        b.lock.Lock()
        equal := b.comparator(*b.val, val)
        *b.val = val
        b.lock.Unlock()

        if !equal {
                b.trigger()
        }

        return nil
}

func baseBindExternal[T any](val *T, comparator func(T, T) bool) *baseExternalItem[T] {
        if val == nil {
                val = new(T) // never allow a nil value pointer
        }
        b := &baseExternalItem[T]{}
        b.comparator = comparator
        b.val = val
        b.old = *val
        return b
}

func baseBindExternalComparable[T bool | float64 | int | rune | string](val *T) *baseExternalItem[T] {
        if val == nil {
                val = new(T) // never allow a nil value pointer
        }
        b := &baseExternalItem[T]{}
        b.comparator = func(a, b T) bool { return a == b }
        b.val = val
        b.old = *val
        return b
}

type baseExternalItem[T any] struct {
        baseItem[T]

        old T
}

func (b *baseExternalItem[T]) Set(val T) error {
        b.lock.Lock()
        if b.comparator(b.old, val) {
                b.lock.Unlock()
                return nil
        }
        *b.val = val
        b.old = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

func (b *baseExternalItem[T]) Reload() error {
        return b.Set(*b.val)
}

type prefBoundBase[T bool | float64 | int | string] struct {
        base
        key   string
        get   func(string) T
        set   func(string, T)
        cache atomic.Pointer[T]
}

func (b *prefBoundBase[T]) Get() (T, error) {
        cache := b.get(b.key)
        b.cache.Store(&cache)
        return cache, nil
}

func (b *prefBoundBase[T]) Set(v T) error {
        b.set(b.key, v)

        b.lock.RLock()
        defer b.lock.RUnlock()
        b.trigger()
        return nil
}

func (b *prefBoundBase[T]) setKey(key string) {
        b.key = key
}

func (b *prefBoundBase[T]) checkForChange() {
        val := b.cache.Load()
        if val != nil && b.get(b.key) == *val {
                return
        }
        b.trigger()
}

type genericItem[T any] interface {
        DataItem
        Get() (T, error)
        Set(T) error
}

func lookupExistingBinding[T any](key string, p fyne.Preferences) (genericItem[T], bool) {
        binds := prefBinds.getBindings(p)
        if binds == nil {
                return nil, false
        }

        if listen, ok := binds.Load(key); listen != nil && ok {
                if l, ok := listen.(genericItem[T]); ok {
                        return l, ok
                }
                fyne.LogError(keyTypeMismatchError+key, nil)
        }

        return nil, false
}

1	package binding
2
3	import (
4	"sync/atomic"
5
6	"fyne.io/fyne/v2"
7	)
8
9	func newBaseItem[T any](comparator func(T, T) bool) *baseItem[T] {
10	return &baseItem[T]{val: new(T), comparator: comparator}
11	}
12
13	func newBaseItemComparable[T bool \| float64 \| int \| rune \| string]() *baseItem[T] {
14	return newBaseItem[T](func(a, b T) bool { return a == b })
15	}	24✔
16		24✔
17	type baseItem[T any] struct {	24✔
18	base
19		21✔
20	comparator func(T, T) bool	84✔
21	val *T
22	}
23
24	func (b *baseItem[T]) Get() (T, error) {
25	b.lock.RLock()
26	defer b.lock.RUnlock()
27
28	if b.val == nil {
29	return *new(T), nil
30	}	359✔
31	return *b.val, nil	359✔
32	}	359✔
33		359✔
34	func (b *baseItem[T]) Set(val T) error {	359✔
UNCOV 35	b.lock.Lock()	×
UNCOV 36	equal := b.comparator(*b.val, val)	×
37	*b.val = val	359✔
38	b.lock.Unlock()
39
40	if !equal {	73✔
41	b.trigger()	73✔
42	}	73✔
43		73✔
44	return nil	73✔
45	}	73✔
46		127✔
47	func baseBindExternal[T any](val T, comparator func(T, T) bool) baseExternalItem[T] {	54✔
48	if val == nil {	54✔
49	val = new(T) // never allow a nil value pointer
50	}	73✔
51	b := &baseExternalItem[T]{}
52	b.comparator = comparator
53	b.val = val	4✔
54	b.old = *val	4✔
UNCOV 55	return b	×
UNCOV 56	}	×
57		4✔
58	func baseBindExternalComparable[T bool \| float64 \| int \| rune \| string](val T) baseExternalItem[T] {	4✔
59	if val == nil {	4✔
60	val = new(T) // never allow a nil value pointer	4✔
61	}	4✔
62	b := &baseExternalItem[T]{}
63	b.comparator = func(a, b T) bool { return a == b }
64	b.val = val	29✔
65	b.old = *val	29✔
UNCOV 66	return b	×
UNCOV 67	}	×
68		29✔
69	type baseExternalItem[T any] struct {	381✔
70	baseItem[T]	29✔
71		29✔
72	old T	29✔
73	}
74
75	func (b *baseExternalItem[T]) Set(val T) error {
76	b.lock.Lock()
77	if b.comparator(b.old, val) {
78	b.lock.Unlock()
79	return nil
80	}
81	*b.val = val	364✔
82	b.old = val	364✔
83	b.lock.Unlock()	580✔
84		216✔
85	b.trigger()	216✔
86	return nil	216✔
87	}	148✔
88		148✔
89	func (b *baseExternalItem[T]) Reload() error {	148✔
90	return b.Set(*b.val)	148✔
91	}	148✔
92		148✔
93	type prefBoundBase[T bool \| float64 \| int \| string] struct {
94	base
95	key string	6✔
96	get func(string) T	6✔
97	set func(string, T)	6✔
98	cache atomic.Pointer[T]
99	}
100
101	func (b *prefBoundBase[T]) Get() (T, error) {
102	cache := b.get(b.key)
103	b.cache.Store(&cache)
104	return cache, nil
105	}
106
107	func (b *prefBoundBase[T]) Set(v T) error {	12✔
108	b.set(b.key, v)	12✔
109		12✔
110	b.lock.RLock()	12✔
111	defer b.lock.RUnlock()	12✔
112	b.trigger()
113	return nil	6✔
114	}	6✔
115		6✔
116	func (b *prefBoundBase[T]) setKey(key string) {	6✔
117	b.key = key	6✔
118	}	6✔
119		6✔
120	func (b *prefBoundBase[T]) checkForChange() {	6✔
121	val := b.cache.Load()
122	if val != nil && b.get(b.key) == *val {	6✔
123	return	6✔
124	}	6✔
125	b.trigger()
126	}	17✔
127		17✔
128	type genericItem[T any] interface {	21✔
129	DataItem	4✔
130	Get() (T, error)	4✔
131	Set(T) error	13✔
132	}
133
134	func lookupExistingBinding[T any](key string, p fyne.Preferences) (genericItem[T], bool) {
135	binds := prefBinds.getBindings(p)
136	if binds == nil {
137	return nil, false
138	}
139
140	if listen, ok := binds.Load(key); listen != nil && ok {	108✔
141	if l, ok := listen.(genericItem[T]); ok {	108✔
142	return l, ok	110✔
143	}	2✔
144	fyne.LogError(keyTypeMismatchError+key, nil)	2✔
145	}
146		208✔
147	return nil, false	204✔
148	}	102✔

fyne-io / fyne / 13091498612

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