176 lines
3.1 KiB
Go
176 lines
3.1 KiB
Go
package maps
|
|
|
|
import "strings"
|
|
|
|
func GetStrAnyVal[T any](m map[string]any, key string, delimiter ...string) (r T, o bool) {
|
|
separator := "."
|
|
if len(delimiter) > 0 && delimiter[0] != "" {
|
|
separator = delimiter[0]
|
|
}
|
|
k := strings.Split(key, separator)
|
|
if len(k) > 1 {
|
|
val, ok := m[k[0]]
|
|
if ok {
|
|
vx, ok := val.(map[string]any)
|
|
if ok {
|
|
r, o = GetStrAnyVal[T](vx, strings.Join(k[1:], separator))
|
|
}
|
|
}
|
|
} else {
|
|
x, ok := m[k[0]]
|
|
if ok {
|
|
vv, ok := x.(T)
|
|
if ok {
|
|
o = true
|
|
r = vv
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetStrAnyValWithDefaults[T any](m map[string]any, key string, defaults T) (r T) {
|
|
r = defaults
|
|
v, ok := GetStrAnyVal[T](m, key)
|
|
if !ok {
|
|
return
|
|
}
|
|
r = v
|
|
return
|
|
}
|
|
|
|
// GetStrMapAnyValWithAny 使用"." 分隔层级
|
|
func GetStrMapAnyValWithAny(key string, v map[string]any) (r any, o bool) {
|
|
k := strings.Split(key, ".")
|
|
if len(k) > 1 {
|
|
val, ok := v[k[0]]
|
|
if ok {
|
|
vx, ok := val.(map[string]any)
|
|
if ok {
|
|
r, o = GetStrMapAnyValWithAny(strings.Join(k[1:], "."), vx)
|
|
}
|
|
}
|
|
} else {
|
|
x, ok := v[k[0]]
|
|
if ok {
|
|
o = true
|
|
r = x
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetAnyAnyMapVal[T any](m map[any]any, k ...any) (r T, o bool) {
|
|
if len(k) > 1 {
|
|
val, ok := m[k[0]]
|
|
if ok {
|
|
vx, ok := val.(map[any]any)
|
|
if ok {
|
|
r, o = GetAnyAnyMapVal[T](vx, k[1:]...)
|
|
}
|
|
}
|
|
} else {
|
|
x, ok := m[k[0]]
|
|
if ok {
|
|
vv, ok := x.(T)
|
|
if ok {
|
|
o = true
|
|
r = vv
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetAnyAnyMapWithAny(v map[any]any, k ...any) (r any, o bool) {
|
|
if len(k) > 1 {
|
|
val, ok := v[k[0]]
|
|
if ok {
|
|
vx, ok := val.(map[any]any)
|
|
if ok {
|
|
r, o = GetAnyAnyMapWithAny(vx, k[1:]...)
|
|
}
|
|
}
|
|
} else {
|
|
x, ok := v[k[0]]
|
|
if ok {
|
|
o = true
|
|
r = x
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetAnyAnyValWithDefaults[T any](m map[any]any, defaults T, key ...any) (r T) {
|
|
r = defaults
|
|
v, ok := GetAnyAnyMapVal[T](m, key...)
|
|
if !ok {
|
|
return
|
|
}
|
|
r = v
|
|
return
|
|
}
|
|
|
|
func RecursiveSetStrVal[T any](m map[string]any, k string, v T, delimiter ...string) {
|
|
del := "."
|
|
if len(delimiter) > 0 && delimiter[0] != "" {
|
|
del = delimiter[0]
|
|
}
|
|
kk := strings.Split(k, del)
|
|
if len(kk) < 1 {
|
|
return
|
|
} else if len(kk) < 2 {
|
|
m[k] = v
|
|
return
|
|
}
|
|
mm, ok := GetStrAnyVal[map[string]any](m, strings.Join(kk[0:len(kk)-1], del))
|
|
if ok {
|
|
mm[kk[len(kk)-1]] = v
|
|
return
|
|
}
|
|
mx, ok := GetStrAnyVal[map[string]any](m, kk[0])
|
|
if !ok {
|
|
m[kk[0]] = map[string]any{}
|
|
mx = m[kk[0]].(map[string]any)
|
|
}
|
|
for i, _ := range kk[0 : len(kk)-2] {
|
|
key := kk[i+1]
|
|
mm, ok := mx[key]
|
|
if !ok {
|
|
mmm := map[string]any{}
|
|
mx[key] = mmm
|
|
mx = mmm
|
|
|
|
} else {
|
|
mx = mm.(map[string]any)
|
|
}
|
|
}
|
|
mx[kk[len(kk)-1]] = v
|
|
}
|
|
|
|
func RecursiveSetAnyVal[T any](m map[any]any, v T, k ...any) {
|
|
if len(k) < 1 {
|
|
return
|
|
} else if len(k) == 1 {
|
|
m[k[0]] = v
|
|
return
|
|
}
|
|
for i, _ := range k[0 : len(k)-1] {
|
|
key := k[0 : i+1]
|
|
mm, ok := GetAnyAnyMapVal[map[any]any](m, key...)
|
|
if !ok {
|
|
mm = map[any]any{}
|
|
preKey := k[0:i]
|
|
if len(preKey) == 0 {
|
|
RecursiveSetAnyVal(m, mm, key...)
|
|
} else {
|
|
m, _ := GetAnyAnyMapVal[map[any]any](m, preKey...)
|
|
RecursiveSetAnyVal(m, mm, k[i])
|
|
}
|
|
}
|
|
}
|
|
key := k[0 : len(k)-1]
|
|
mm, _ := GetAnyAnyMapVal[map[any]any](m, key...)
|
|
mm[k[len(k)-1]] = v
|
|
}
|