niki/vendor/github.com/redis/go-redis/v9/internal/hscan/structmap.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

}