#### Version 0.7.13

* Feature: Added the "composite-field" tag to continue expanding and searching for corresponding field mappings when encountering composite fields in a Struct. Currently, only one level of expansion is supported.
* Tips: Thanks to @naeemaei for issue #39
* For my birthday!
* you can use like this:
``` go
  // Base model
  type BaseModel struct {
      Id    int `json:"id"`
  }

  // Country model
  type Country struct {
      BaseModel `json:"composite-field"`
      Name      string `json:"name"`
  }
```
* 2023-04-15 19:00 in ShangHai

Author: devfeel

constant.go

@@ -1,12 +1,13 @@
 package mapper
 
 const (
-	packageVersion = "0.7.12"
-	mapperTagKey   = "mapper"
-	jsonTagKey     = "json"
-	IgnoreTagValue = "-"
-	nameConnector  = "_"
-	formatTime     = "15:04:05"
-	formatDate     = "2006-01-02"
-	formatDateTime = "2006-01-02 15:04:05"
+	packageVersion         = "0.7.13"
+	mapperTagKey           = "mapper"
+	jsonTagKey             = "json"
+	IgnoreTagValue         = "-"
+	CompositeFieldTagValue = "composite-field"
+	nameConnector          = "_"
+	formatTime             = "15:04:05"
+	formatDate             = "2006-01-02"
+	formatDateTime         = "2006-01-02 15:04:05"
 )

example/object/go.mod

@@ -5,41 +5,33 @@ import (
 	"github.com/devfeel/mapper"
 )
 
-type (
-	User struct {
-		Name  string `json:"name" mapper:"name"`
-		Class int    `mapper:"class"`
-		Age   int    `json:"age" mapper:"-"`
-	}
-
-	Student struct {
-		Name  string `json:"name" mapper:"name"`
-		Class int    `mapper:"class"`
-		Age   []int  `json:"age" mapper:"-"`
-	}
-)
-
-func main() {
-	user := &User{Name: "shyandsy", Class: 1, Age: 10}
-	student := &Student{}
-
-	// create mapper object
-	m := mapper.NewMapper()
-
-	// in the version < v0.7.8, we will use field name as key when mapping structs
-	// we keep it as default behavior in this version
-	m.SetEnableFieldIgnoreTag(true)
-
-	student.Age = []int{1}
+// Base model
+type BaseModel struct {
+	Id    int `json:"id"`
+	NameX string
+}
 
-	// disable the json tag
-	m.SetEnabledJsonTag(false)
+// Country model
+type Country struct {
+	BaseModel `json:"composite-field"`
+	Name      string `json:"name"`
+}
 
-	// student::age should be 1
-	m.Mapper(user, student)
+type CountryRes struct {
+	Id   int    `json:"id"`
+	Name string `json:"name"`
+}
 
-	fmt.Println("user:")
-	fmt.Println(user)
-	fmt.Println("student:")
-	fmt.Println(student)
+func main() {
+	var items *[]Country = new([]Country)
+	c := &Country{BaseModel{1, "1X"}, "111"}
+	*items = append(*items, *c)
+	var mitems *[]CountryRes = new([]CountryRes)
+	mapper.MapperSlice(items, mitems)
+	fmt.Println(items)
+	fmt.Println(mitems)
+
+	to := &CountryRes{}
+	mapper.Mapper(c, to)
+	fmt.Println(to)
 }

example/object/go.sum

@@ -93,58 +93,83 @@ func (dm *mapperObject) elemMapper(fromElem, toElem reflect.Value) error {
 	return nil
 }
 
+// elemToStruct to convert the different structs for assignment.
 func (dm *mapperObject) elemToStruct(fromElem, toElem reflect.Value) {
 	for i := 0; i < fromElem.NumField(); i++ {
 		fromFieldInfo := fromElem.Field(i)
 		fieldName := dm.getFieldName(fromElem, i)
 		if fieldName == IgnoreTagValue {
 			continue
 		}
-
-		// check field is exists
-		realFieldName, exists := dm.CheckExistsField(toElem, fieldName)
-		if !exists {
-			continue
+		if fieldName == CompositeFieldTagValue &&
+			fromFieldInfo.Kind() == reflect.Struct {
+			//If composite fields are identified, further decomposition and judgment will be taken.
+			fromElem := fromFieldInfo
+			for i := 0; i < fromElem.NumField(); i++ {
+				fromFieldInfo := fromElem.Field(i)
+				fieldName := dm.getFieldName(fromElem, i)
+				if fieldName == IgnoreTagValue {
+					continue
+				}
+				err := dm.convertstructfieldInternal(fieldName, fromFieldInfo, toElem)
+				if err != nil {
+					fmt.Println("auto mapper failed", fromFieldInfo, "error", err.Error())
+				}
+			}
+		} else {
+			err := dm.convertstructfieldInternal(fieldName, fromFieldInfo, toElem)
+			if err != nil {
+				fmt.Println("auto mapper failed", fromFieldInfo, "error", err.Error())
+			}
 		}
+	}
+}
 
-		toFieldInfo := toElem.FieldByName(realFieldName)
-		// check field is same type
-		if dm.enabledTypeChecking {
-			if fromFieldInfo.Kind() != toFieldInfo.Kind() {
-				continue
-			}
+// convertstructfieldInternal to convert the fields of different structs for assignment.
+func (dm *mapperObject) convertstructfieldInternal(fieldName string, fromFieldInfo, toElem reflect.Value) error {
+	// check field is exists
+	realFieldName, exists := dm.CheckExistsField(toElem, fieldName)
+	if !exists {
+		return nil
+	}
+
+	toFieldInfo := toElem.FieldByName(realFieldName)
+	// check field is same type
+	if dm.enabledTypeChecking {
+		if fromFieldInfo.Kind() != toFieldInfo.Kind() {
+			return nil
 		}
+	}
 
-		if dm.enabledMapperStructField &&
-			toFieldInfo.Kind() == reflect.Struct && fromFieldInfo.Kind() == reflect.Struct &&
-			toFieldInfo.Type() != fromFieldInfo.Type() &&
-			!dm.checkIsTypeWrapper(toFieldInfo) && !dm.checkIsTypeWrapper(fromFieldInfo) {
-			x := reflect.New(toFieldInfo.Type()).Elem()
-			err := dm.elemMapper(fromFieldInfo, x)
-			if err != nil {
-				fmt.Println("auto mapper failed", fromFieldInfo, "=>", toFieldInfo, "error", err.Error())
-			} else {
-				toFieldInfo.Set(x)
-			}
+	if dm.enabledMapperStructField &&
+		toFieldInfo.Kind() == reflect.Struct && fromFieldInfo.Kind() == reflect.Struct &&
+		toFieldInfo.Type() != fromFieldInfo.Type() &&
+		!dm.checkIsTypeWrapper(toFieldInfo) && !dm.checkIsTypeWrapper(fromFieldInfo) {
+		x := reflect.New(toFieldInfo.Type()).Elem()
+		err := dm.elemMapper(fromFieldInfo, x)
+		if err != nil {
+			return err
 		} else {
-			isSet := false
-			if dm.enabledAutoTypeConvert {
-				if dm.DefaultTimeWrapper.IsType(fromFieldInfo) && toFieldInfo.Kind() == reflect.Int64 {
-					fromTime := fromFieldInfo.Interface().(time.Time)
-					toFieldInfo.Set(reflect.ValueOf(TimeToUnix(fromTime)))
-					isSet = true
-				} else if dm.DefaultTimeWrapper.IsType(toFieldInfo) && fromFieldInfo.Kind() == reflect.Int64 {
-					fromTime := fromFieldInfo.Interface().(int64)
-					toFieldInfo.Set(reflect.ValueOf(UnixToTime(fromTime)))
-					isSet = true
-				}
-			}
-			if !isSet {
-				toFieldInfo.Set(fromFieldInfo)
+			toFieldInfo.Set(x)
+		}
+	} else {
+		isSet := false
+		if dm.enabledAutoTypeConvert {
+			if dm.DefaultTimeWrapper.IsType(fromFieldInfo) && toFieldInfo.Kind() == reflect.Int64 {
+				fromTime := fromFieldInfo.Interface().(time.Time)
+				toFieldInfo.Set(reflect.ValueOf(TimeToUnix(fromTime)))
+				isSet = true
+			} else if dm.DefaultTimeWrapper.IsType(toFieldInfo) && fromFieldInfo.Kind() == reflect.Int64 {
+				fromTime := fromFieldInfo.Interface().(int64)
+				toFieldInfo.Set(reflect.ValueOf(UnixToTime(fromTime)))
+				isSet = true
 			}
 		}
-
+		if !isSet {
+			toFieldInfo.Set(fromFieldInfo)
+		}
 	}
+	return nil
 }
 
 func (dm *mapperObject) elemToMap(fromElem, toElem reflect.Value) {

example/object/main.go

@@ -1,5 +1,24 @@
 ## devfeel/mapper
 
+#### Version 0.7.13
+* Feature: Added the "composite-field" tag to continue expanding and searching for corresponding field mappings when encountering composite fields in a Struct. Currently, only one level of expansion is supported.
+* Tips: Thanks to @naeemaei for issue #39
+* For my birthday!
+* you can use like this:
+``` go
+  // Base model
+  type BaseModel struct {
+      Id    int `json:"id"`
+  }
+  
+  // Country model
+  type Country struct {
+      BaseModel `json:"composite-field"`
+      Name      string `json:"name"`
+  }
+```
+* 2023-04-15 19:00 in ShangHai
+
 #### Version 0.7.12
 * Refactor: Solve the problem of repeated function implementation, rewrite "mapperObject.Getfieldname" direct call "mapperObject.getFieldName".
 * Refactor: Rewrite mapperObject.cleanRegisterValue, it will be reset registerMap & fieldNameMap.