mirror of https://github.com/go-redis/redis.git
126 lines
2.5 KiB
Go
126 lines
2.5 KiB
Go
package hscan
|
|
|
|
import (
|
|
"encoding"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/redis/go-redis/v9/internal/util"
|
|
)
|
|
|
|
// structMap contains the map of struct fields for target structs
|
|
// indexed by the struct type.
|
|
type structMap struct {
|
|
m sync.Map
|
|
}
|
|
|
|
func newStructMap() *structMap {
|
|
return new(structMap)
|
|
}
|
|
|
|
func (s *structMap) get(t reflect.Type) *structSpec {
|
|
if v, ok := s.m.Load(t); ok {
|
|
return v.(*structSpec)
|
|
}
|
|
|
|
spec := newStructSpec(t, "redis")
|
|
s.m.Store(t, spec)
|
|
return spec
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// structSpec contains the list of all fields in a target struct.
|
|
type structSpec struct {
|
|
m map[string]*structField
|
|
}
|
|
|
|
func (s *structSpec) set(tag string, sf *structField) {
|
|
s.m[tag] = sf
|
|
}
|
|
|
|
func newStructSpec(t reflect.Type, fieldTag string) *structSpec {
|
|
numField := t.NumField()
|
|
out := &structSpec{
|
|
m: make(map[string]*structField, numField),
|
|
}
|
|
|
|
for i := 0; i < numField; i++ {
|
|
f := t.Field(i)
|
|
|
|
tag := f.Tag.Get(fieldTag)
|
|
if tag == "" || tag == "-" {
|
|
continue
|
|
}
|
|
|
|
tag = strings.Split(tag, ",")[0]
|
|
if tag == "" {
|
|
continue
|
|
}
|
|
|
|
// Use the built-in decoder.
|
|
kind := f.Type.Kind()
|
|
if kind == reflect.Pointer {
|
|
kind = f.Type.Elem().Kind()
|
|
}
|
|
out.set(tag, &structField{index: i, fn: decoders[kind]})
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// structField represents a single field in a target struct.
|
|
type structField struct {
|
|
index int
|
|
fn decoderFunc
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
type StructValue struct {
|
|
spec *structSpec
|
|
value reflect.Value
|
|
}
|
|
|
|
func (s StructValue) Scan(key string, value string) error {
|
|
field, ok := s.spec.m[key]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
v := s.value.Field(field.index)
|
|
isPtr := v.Kind() == reflect.Ptr
|
|
|
|
if isPtr && v.IsNil() {
|
|
v.Set(reflect.New(v.Type().Elem()))
|
|
}
|
|
if !isPtr && v.Type().Name() != "" && v.CanAddr() {
|
|
v = v.Addr()
|
|
isPtr = true
|
|
}
|
|
|
|
if isPtr && v.Type().NumMethod() > 0 && v.CanInterface() {
|
|
switch scan := v.Interface().(type) {
|
|
case Scanner:
|
|
return scan.ScanRedis(value)
|
|
case encoding.TextUnmarshaler:
|
|
return scan.UnmarshalText(util.StringToBytes(value))
|
|
}
|
|
}
|
|
|
|
if isPtr {
|
|
v = v.Elem()
|
|
}
|
|
|
|
if err := field.fn(v, value); err != nil {
|
|
t := s.value.Type()
|
|
return fmt.Errorf("cannot scan redis.result %s into struct field %s.%s of type %s, error-%s",
|
|
value, t.Name(), t.Field(field.index).Name, t.Field(field.index).Type, err.Error())
|
|
}
|
|
return nil
|
|
}
|