copier: 支持类型转换 about ekit HOT 20 CLOSED

var converter map[string]*Converter

type A struct {
	Age int `target:AgeStr,handler:IntToString`
}

type B struct {
	AgeStr string ``
}

type Converter interface {
	Convert(src any) (any, error)
}

type IntToString struct {
}

func (i IntToString) Convert(src any) (any, error) {
	return strconv.Itoa(src.(int)), nil
}

    if srcFieldTypStruct.Type.Kind() != dstFieldTypStruct.Type.Kind() {
        return newErrKindNotMatchError(srcFieldTypStruct.Type.Kind(), dstFieldTypStruct.Type.Kind(), dstFieldTypStruct.Name)
    }

// Converter 从 src类型到dst类型的接口
type Converter interface {
	Convert(src any) (any, error)
}

// ConverterFunc 函数式的写法，它也实现了 Converter 接口
type ConverterFunc func(src any) (any, error)

// ConverterWithCheckFunc 在使用newConverterWithCheckFunc后，我们在copier中实际用到的函数
// 1. srcVal的类型对应 ConverterFunc 中src的类型的值
// 2. dstVal对应 ConverterFunc 中的返回any的指针类型，从而在内部进行拷贝
type ConverterWithCheckFunc func(srcVal reflect.Value, dstPtrVal reflect.Value) error

func newConverterWithCheckFunc(converter Converter) (ConverterWithCheckFunc, error) {
	val := reflect.ValueOf(converter)
	convertMethod := val.MethodByName("Convert")
	// 检查方法是否存在
	if !convertMethod.IsValid() {
		return nil, errors.New("convert method not found")
	}
	// 获取方法的类型
	methodType := convertMethod.Type()
	// 获取参数和返回值的类型
	srcType := methodType.In(0)  // 获取第一个参数的类型
	dstType := methodType.Out(0) // 获取第一个返回值的类型

	return func(srcVal reflect.Value, dstPtrVal reflect.Value) error {
		if reflect.TypeOf(srcVal) != srcType {
			return errors.New("invalid src")
		}

		dstTypePtr := reflect.TypeOf(dstPtrVal)
		if dstTypePtr.Kind() != reflect.Ptr {
			return errors.New("dst must be pointer")
		}
		if dstTypePtr.Elem() != dstType {
			return errors.New("invalid dst")
		}

		dstVal, err := converter.Convert(srcVal.Interface())
		if err != nil {
			return err
		}

		// 获取指针内的元素，并设置值
		dstElem := dstPtrVal.Elem()
		if !dstElem.CanSet() {
			return fmt.Errorf("dst cannot be set")
		}
		dstElem.Set(reflect.ValueOf(dstVal))
		return nil
	}, nil
}

// options 执行复制操作时的可选配置
type options struct {
        covertFields map[string]ConverterWithCheckFunc
	// ignoreFields 执行复制操作时，需要忽略的字段
	ignoreFields *set.MapSet[string]
}

type Converter interface {
	Convert(src any) (any, error)
}

type ConvertFunc[Src any, Dst any] func(src Src) (Dst, error)

func (c ConvertFunc[Src, Dst]) Convert(src any) (any, error) {
	// 要对 src 的 nil 进行特殊处理
	dst, err := c(src.(Src))
	return dst, err
}

type converter interface {
	Convert(src any) (any, error)
}

type Converter[Src any, Dst any] func(src Src) (Dst, error)

func (c Converter[Src, Dst]) Convert(src any) (any, error) {
	// 要对 src 的 nil 进行特殊处理
	srcVal, ok := src.(Src)
	if !ok {
		return nil, errors.New("xxxxx")
	}
	dst, err := c(srcVal)
	// 没发判断 dst 是否符合······
	return dst, err
}

func NewTime2String(pattern string) Converter[time.Time, string] {
	return func(src time.Time) (string, error) {
		return src.Format(pattern), nil
	}
}

type Converter[Src any, Dst any] interface {
	Convert(src Src) (Dst, error)
}

type Time2String struct {
	Pattern string // 就是格式化的目标格式，那个 2006 啥的
}

func (t Time2String) Convert(src time.Time) (string, error) {
	return src.Format(t.Pattern), nil
}

func ConvertField(field string, c any) option.Option[options] {
	return func(opt *options) {
		if field == "" || c == nil {
			return
		}
		if opt.fieldsConvert == nil {
			opt.fieldsConvert = make(map[string]Converter, 16)
		}
		opt.fieldsConvert[field] = c
	}
}

// options 执行复制操作时的可选配置
type options struct {
	// ignoreFields 执行复制操作时，需要忽略的字段
	ignoreFields *set.MapSet[string]
	converters   map[string]converterWrapper
}

type converterWrapper func(src any) (any, error)

func ConvertField[Src any, Dst any](field string, c Converter[Src, Dst]) option.Option[options] {
	return func(t *options) {
		t.converters[field] = func(src any) (any, error) {
			if src == nil {
				dst, err := c.Convert(nil)
				return dst, err
			}
			srcVal, ok := src.(Src)
			if !ok {
				var dst Dst
				return dst, errors.New("报错")
			}
			dst, err := c.Convert(srcVal)
			return dst, err
		}
	}
}

// options 执行复制操作时的可选配置
type options struct {
	// ignoreFields 执行复制操作时，需要忽略的字段
	ignoreFields *set.MapSet[string]
	converters   map[string]converterWrapper
}

type converterWrapper func(src any) (any, error)

func ConvertField[Src any, Dst any](field string, c Converter[Src, Dst]) option.Option[options] {
	return func(t *options) {
		t.converters[field] = func(src any) (any, error) {
			if src == nil {
				dst, err := c.Convert(nil)
				return dst, err
			}
			srcVal, ok := src.(Src)
			if !ok {
				var dst Dst
				return dst, errors.New("报错")
			}
			dst, err := c.Convert(srcVal)
			return dst, err
		}
	}
}

	copier, err := NewReflectCopier[ArraySrc, ArrayDst]()
	if err != nil {
		return nil, err
	}
	return copier.Copy(&ArraySrc{
		A: []SimpleSrc{
			{
				Name:    "大明",
				Age:     ekit.ToPtr[int](18),
				Friends: []string{"Tom", "Jerry"},
			},
			{
				Name:    "小明",
				Age:     ekit.ToPtr[int](8),
				Friends: []string{"Tom"},
			},
		},
	}, ConvertField[[]string, []string]("Friends", func(src []string) ([]string, error) {
		for i, friend := range src {
			src[i] = friend + "太丑了"
		}
		return src, nil
	}))

type ConvertHandler[Src any, Dst any] func(src Src) (Dst, error)

func ConvertField[Src any, Dst any](field string, c converter.ConvertHandler[Src, Dst]) option.Option[options]