func resolveTypeRecursive()

in pkg/model/k8s/configsource/reflect.go [41:101]


func resolveTypeRecursive(path string, current reflect.Type, resolver *merger.MergeConfigResolver) error {
	if strings.Count(path, ".") > MAXIMUM_STRUCTURE_DEPTH {
		return fmt.Errorf("maximum structure depth reached. is this a recursive structure?")
	}
	kind := current.Kind()
	switch kind {
	case reflect.Struct:
		fieldCount := current.NumField()
		for i := 0; i < fieldCount; i++ {
			field := current.Field(i)
			fieldKind := field.Type.Kind()
			json, ok := field.Tag.Lookup("json")
			if !ok {
				continue
			}
			jsonSegments := strings.Split(json, ",")
			if slices.Contains[[]string](jsonSegments, "inline") {
				err := resolveTypeRecursive(path, field.Type, resolver)
				if err != nil {
					return err
				}
			}
			jsonName := jsonSegments[0]
			jsonFieldPath := fmt.Sprintf("%s.%s", path, jsonName)
			if fieldKind == reflect.Slice || fieldKind == reflect.Array {
				patchStrategy, ok := field.Tag.Lookup("patchStrategy")
				if !ok || patchStrategy != "merge" {
					resolver.MergeStrategies[jsonFieldPath] = merger.MergeStrategyReplace
				} else {
					resolver.MergeStrategies[jsonFieldPath] = merger.MergeStrategyMerge
					patchMergeKey, ok := field.Tag.Lookup("patchMergeKey")
					if ok {
						resolver.MergeKeys[jsonFieldPath] = patchMergeKey
					} else {
						resolver.MergeKeys[jsonFieldPath] = ""
					}
				}
				err := resolveTypeRecursive(jsonFieldPath+"[]", field.Type.Elem(), resolver)
				if err != nil {
					return err
				}
			} else if fieldKind == reflect.Struct || fieldKind == reflect.Ptr {
				fieldType := field.Type
				if fieldKind == reflect.Ptr {
					fieldType = field.Type.Elem()
				}
				err := resolveTypeRecursive(jsonFieldPath, fieldType, resolver)
				if err != nil {
					return err
				}
			}
		}
		return nil
	case reflect.Chan:
		return fmt.Errorf("unsupported kind %s", current.Kind())
	case reflect.Ptr:
		return fmt.Errorf("unsupported kind %s", current.Kind())
	default:
		return nil
	}
}