func GetValueByType()

in utils/util.go [110:307]

• 195 lines of code
• 73 McCabe index (conditional complexity)

func GetValueByType(value interface{}, vtype string) interface{} {
	switch vtype {
	case "int":
		return ToInt(value, 0)
	case "string":
		return ToString(value, "")
	case "float64":
		return ToFloat(value, float64(0))
	case "int64":
		return ToInt64(value, 0)
	case "bigint":
		return ToInt64(value, 0)
	case "bool":
		return ToBool(value, false)
	case "list<string>":
		return ToStringArray(value)
	case "list<int>":
		return ToIntArray(value)
	case "list<int64>":
		if vals, ok := value.([]any); ok {
			values := make([]int64, 0, len(vals))
			for _, v := range vals {
				values = append(values, ToInt64(v, 0))
			}
			return values
		}
	case "list<double>":
		if vals, ok := value.([]any); ok {
			values := make([]float64, 0, len(vals))
			for _, v := range vals {
				values = append(values, ToFloat(v, 0))
			}
			return values
		}
	case "list<float>":
		if vals, ok := value.([]any); ok {
			values := make([]float32, 0, len(vals))
			for _, v := range vals {
				values = append(values, ToFloat32(v, 0))
			}
			return values
		}
	case "list<list<float>>":
		if vals, ok := value.([]any); ok {
			values := make([][]float32, 0, len(vals))
			for _, vlist := range vals {
				if lists, ok := vlist.([]any); ok {
					list := make([]float32, 0, len(lists))
					for _, v := range lists {
						list = append(list, ToFloat32(v, 0))
					}
					values = append(values, list)
				}
			}

			return values
		}
	case "list<list<double>>":
		if vals, ok := value.([]any); ok {
			values := make([][]float64, 0, len(vals))
			for _, vlist := range vals {
				if lists, ok := vlist.([]any); ok {
					list := make([]float64, 0, len(lists))
					for _, v := range lists {
						list = append(list, ToFloat(v, 0))
					}
					values = append(values, list)
				}
			}

			return values
		}
	case "map<string,string>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[string]string, len(vals))
			for k, v := range vals {
				values[k] = ToString(v, "")
			}
			return values
		}
	case "map<string,int>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[string]int, len(vals))
			for k, v := range vals {
				values[k] = ToInt(v, 0)
			}
			return values
		}
	case "map<string,int64>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[string]int64, len(vals))
			for k, v := range vals {
				values[k] = ToInt64(v, 0)
			}
			return values
		}
	case "map<string,float>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[string]float32, len(vals))
			for k, v := range vals {
				values[k] = ToFloat32(v, 0)
			}
			return values
		}
	case "map<string,double>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[string]float64, len(vals))
			for k, v := range vals {
				values[k] = ToFloat(v, 0)
			}
			return values
		}
	case "map<int,int>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int]int, len(vals))
			for k, v := range vals {
				values[ToInt(k, 0)] = ToInt(v, 0)
			}
			return values
		}
	case "map<int,int64>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int]int64, len(vals))
			for k, v := range vals {
				values[ToInt(k, 0)] = ToInt64(v, 0)
			}
			return values
		}
	case "map<int,double>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int]float64, len(vals))
			for k, v := range vals {
				values[ToInt(k, 0)] = ToFloat(v, 0)
			}
			return values
		}
	case "map<int,float>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int]float32, len(vals))
			for k, v := range vals {
				values[ToInt(k, 0)] = ToFloat32(v, 0)
			}
			return values
		}
	case "map<int,string>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int]string, len(vals))
			for k, v := range vals {
				values[ToInt(k, 0)] = ToString(v, "")
			}
			return values
		}
	case "map<int64,int>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int64]int, len(vals))
			for k, v := range vals {
				values[ToInt64(k, 0)] = ToInt(v, 0)
			}
			return values
		}
	case "map<int64,int64>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int64]int64, len(vals))
			for k, v := range vals {
				values[ToInt64(k, 0)] = ToInt64(v, 0)
			}
			return values
		}
	case "map<int64,double>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int64]float64, len(vals))
			for k, v := range vals {
				values[ToInt64(k, 0)] = ToFloat(v, 0)
			}
			return values
		}
	case "map<int64,float>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int64]float32, len(vals))
			for k, v := range vals {
				values[ToInt64(k, 0)] = ToFloat32(v, 0)
			}
			return values
		}
	case "map<int64,string>":
		if vals, ok := value.(map[string]any); ok {
			values := make(map[int64]string, len(vals))
			for k, v := range vals {
				values[ToInt64(k, 0)] = ToString(v, "")
			}
			return values
		}
	default:
		return value
	}

	return value
}