imp

Author: shamaton

internal/decoding/struct.go

@@ -9,12 +9,27 @@ import (
 )
 
 type structCacheTypeMap struct {
-	keys    [][]byte
+	keys [][]byte
+
+	// fast path detection
+	hasEmbedded bool
+
+	// fast path (hasEmbedded == false): direct field access
+	simpleIndexes []int
+
+	// embedded path (hasEmbedded == true): path-based access
 	indexes [][]int // field path (support for embedded structs)
 }
 
 type structCacheTypeArray struct {
-	m [][]int // field path (support for embedded structs)
+	// fast path detection
+	hasEmbedded bool
+
+	// fast path (hasEmbedded == false): direct field access
+	simpleIndexes []int
+
+	// embedded path (hasEmbedded == true): path-based access
+	indexes [][]int // field path (support for embedded structs)
 }
 
 // struct cache map
@@ -87,25 +102,57 @@ func (d *decoder) setStructFromArray(rv reflect.Value, offset int, k reflect.Kin
 	if !findCache {
 		scta = &structCacheTypeArray{}
 		fields := d.CollectFields(rv.Type(), nil)
+
+		// detect embedded fields
+		hasEmbedded := false
+		for _, f := range fields {
+			if len(f.Path) > 1 || len(f.OmitPaths) > 0 {
+				hasEmbedded = true
+				break
+			}
+		}
+		scta.hasEmbedded = hasEmbedded
+
 		for _, field := range fields {
-			scta.m = append(scta.m, field.Path)
+			if hasEmbedded {
+				scta.indexes = append(scta.indexes, field.Path)
+			} else {
+				scta.simpleIndexes = append(scta.simpleIndexes, field.Path[0])
+			}
 		}
 		mapSCTA.Store(rv.Type(), scta)
 	} else {
 		scta = cache.(*structCacheTypeArray)
 	}
+
 	// set value
-	for i := 0; i < l; i++ {
-		if i < len(scta.m) {
-			fieldValue := getFieldByPath(rv, scta.m[i])
-			o, err = d.decode(fieldValue, o)
-			if err != nil {
-				return 0, err
+	if scta.hasEmbedded {
+		for i := 0; i < l; i++ {
+			if i < len(scta.indexes) {
+				fieldValue := getFieldByPath(rv, scta.indexes[i])
+				o, err = d.decode(fieldValue, o)
+				if err != nil {
+					return 0, err
+				}
+			} else {
+				o, err = d.jumpOffset(o)
+				if err != nil {
+					return 0, err
+				}
 			}
-		} else {
-			o, err = d.jumpOffset(o)
-			if err != nil {
-				return 0, err
+		}
+	} else {
+		for i := 0; i < l; i++ {
+			if i < len(scta.simpleIndexes) {
+				o, err = d.decode(rv.Field(scta.simpleIndexes[i]), o)
+				if err != nil {
+					return 0, err
+				}
+			} else {
+				o, err = d.jumpOffset(o)
+				if err != nil {
+					return 0, err
+				}
 			}
 		}
 	}
@@ -128,53 +175,109 @@ func (d *decoder) setStructFromMap(rv reflect.Value, offset int, k reflect.Kind)
 	if !cacheFind {
 		sctm = &structCacheTypeMap{}
 		fields := d.CollectFields(rv.Type(), nil)
+
+		// detect embedded fields
+		hasEmbedded := false
+		for _, f := range fields {
+			if len(f.Path) > 1 || len(f.OmitPaths) > 0 {
+				hasEmbedded = true
+				break
+			}
+		}
+		sctm.hasEmbedded = hasEmbedded
+
 		for _, field := range fields {
 			sctm.keys = append(sctm.keys, []byte(field.Name))
-			sctm.indexes = append(sctm.indexes, field.Path)
+			if hasEmbedded {
+				sctm.indexes = append(sctm.indexes, field.Path)
+			} else {
+				sctm.simpleIndexes = append(sctm.simpleIndexes, field.Path[0])
+			}
 		}
 		mapSCTM.Store(rv.Type(), sctm)
 	} else {
 		sctm = cache.(*structCacheTypeMap)
 	}
 
-	for i := 0; i < l; i++ {
-		dataKey, o2, err := d.asStringByte(o, k)
-		if err != nil {
-			return 0, err
-		}
-
-		fieldPath := []int(nil)
-		for keyIndex, keyBytes := range sctm.keys {
-			if len(keyBytes) != len(dataKey) {
-				continue
+	if sctm.hasEmbedded {
+		for i := 0; i < l; i++ {
+			dataKey, o2, err := d.asStringByte(o, k)
+			if err != nil {
+				return 0, err
 			}
 
-			found := true
-			for dataIndex := range dataKey {
-				if dataKey[dataIndex] != keyBytes[dataIndex] {
-					found = false
+			fieldPath := []int(nil)
+			for keyIndex, keyBytes := range sctm.keys {
+				if len(keyBytes) != len(dataKey) {
+					continue
+				}
+
+				found := true
+				for dataIndex := range dataKey {
+					if dataKey[dataIndex] != keyBytes[dataIndex] {
+						found = false
+						break
+					}
+				}
+				if found {
+					fieldPath = sctm.indexes[keyIndex]
 					break
 				}
 			}
-			if found {
-				fieldPath = sctm.indexes[keyIndex]
-				break
+
+			if fieldPath != nil {
+				fieldValue := getFieldByPath(rv, fieldPath)
+				o2, err = d.decode(fieldValue, o2)
+				if err != nil {
+					return 0, err
+				}
+			} else {
+				o2, err = d.jumpOffset(o2)
+				if err != nil {
+					return 0, err
+				}
 			}
+			o = o2
 		}
-
-		if fieldPath != nil {
-			fieldValue := getFieldByPath(rv, fieldPath)
-			o2, err = d.decode(fieldValue, o2)
+	} else {
+		for i := 0; i < l; i++ {
+			dataKey, o2, err := d.asStringByte(o, k)
 			if err != nil {
 				return 0, err
 			}
-		} else {
-			o2, err = d.jumpOffset(o2)
-			if err != nil {
-				return 0, err
+
+			fieldIndex := -1
+			for keyIndex, keyBytes := range sctm.keys {
+				if len(keyBytes) != len(dataKey) {
+					continue
+				}
+
+				found := true
+				for dataIndex := range dataKey {
+					if dataKey[dataIndex] != keyBytes[dataIndex] {
+						found = false
+						break
+					}
+				}
+				if found {
+					fieldIndex = sctm.simpleIndexes[keyIndex]
+					break
+				}
+			}
+
+			if fieldIndex >= 0 {
+				o2, err = d.decode(rv.Field(fieldIndex), o2)
+				if err != nil {
+					return 0, err
+				}
+			} else {
+				o2, err = d.jumpOffset(o2)
+				if err != nil {
+					return 0, err
+				}
 			}
+			o = o2
 		}
-		o = o2
 	}
 	return o, nil
 }