13061161551

Committed 30 Jan 2025 09:01PM UTC coverage: 60.858% (+1.7%) from 59.117%

Build # 13061161551

Build Type

Pull #5431

github

Committed by

dweymouth

Commit Message

address review comments

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

Run Details

22 of 52 new or added lines in 6 files covered. (42.31%)

528 existing lines in 26 files now uncovered.

25006 of 41089 relevant lines covered (60.86%)

817.06 hits per line

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

86.33

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

fyne-io / fyne / 13061161551

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