74 lines
1.1 KiB
Go
74 lines
1.1 KiB
Go
package nestedmaps
|
|
|
|
type next[NK comparable, M ~map[NK]NV, NV any] struct {
|
|
last Path[M]
|
|
key NK
|
|
}
|
|
|
|
func (me next[NK, CV, NV]) Exists() bool {
|
|
_, ok := me.last.Get()[me.key]
|
|
return ok
|
|
}
|
|
|
|
func (me next[NK, CV, NV]) Get() NV {
|
|
return me.last.Get()[me.key]
|
|
}
|
|
|
|
func (me next[NK, CV, NV]) Set(value NV) {
|
|
if me.last.Get() == nil {
|
|
me.last.Set(make(CV))
|
|
}
|
|
me.last.Get()[me.key] = value
|
|
}
|
|
|
|
func (me next[NK, CV, NV]) Delete() {
|
|
m := me.last.Get()
|
|
delete(m, me.key)
|
|
if len(m) == 0 {
|
|
me.last.Delete()
|
|
}
|
|
}
|
|
|
|
func Next[K comparable, M ~map[K]V, V any](
|
|
last Path[M],
|
|
key K,
|
|
) Path[V] {
|
|
ret := next[K, M, V]{}
|
|
ret.last = last
|
|
ret.key = key
|
|
return ret
|
|
}
|
|
|
|
type root[K comparable, V any, M ~map[K]V] struct {
|
|
m *M
|
|
}
|
|
|
|
func (me root[K, V, M]) Exists() bool {
|
|
return *me.m != nil
|
|
}
|
|
|
|
func (me root[K, V, M]) Get() M {
|
|
return *me.m
|
|
}
|
|
|
|
func (me root[K, V, M]) Set(value M) {
|
|
*me.m = value
|
|
}
|
|
|
|
func (me root[K, V, M]) Delete() {
|
|
*me.m = nil
|
|
}
|
|
|
|
func Begin[K comparable, M ~map[K]V, V any](m *M) Path[M] {
|
|
ret := root[K, V, M]{}
|
|
ret.m = m
|
|
return ret
|
|
}
|
|
|
|
type Path[V any] interface {
|
|
Set(V)
|
|
Get() V
|
|
Exists() bool
|
|
Delete()
|
|
}
|