func()

in nimo-shake/protocal/type_converter.go [147:242]
83 lines of code
21 McCabe index (conditional complexity)

func (tc *TypeConverter) convertToDetail(name string, input interface{}) interface{} {

	funcStartT := time.Now()
	defer LOG.Debug("convertToDetail_func name[%v] input[%v] duration[%v]", name, input, time.Since(funcStartT))

	switch name {
	case "B":
		list := input.([]interface{})
		output := make([]byte, 0, len(list))
		for _, ele := range list {
			output = append(output, ele.(byte))
		}
		return output
	case "BS":
		list := input.([]interface{})
		output := make([][]byte, 0, len(list))
		for _, ele := range list {
			inner := tc.convertToDetail("B", ele)
			output = append(output, inner.([]byte))
		}
		return output
	case "NS":
		list := input.([]interface{})

		var nType reflect.Type
		for _, ele := range list {
			inner := tc.convertToDetail("N", ele)
			nType = reflect.TypeOf(inner)
			break
		}

		if nType.Name() == "int" {

			output := make([]int, 0, len(list))
			for _, ele := range list {
				inner := tc.convertToDetail("N", ele)
				output = append(output, inner.(int))
			}

			return output
		} else {
			output := make([]primitive.Decimal128, 0, len(list))
			for _, ele := range list {
				inner := tc.convertToDetail("N", ele)
				output = append(output, inner.(primitive.Decimal128))
			}

			return output
		}

	case "SS":
		list := input.([]interface{})
		output := make([]string, 0, len(list))
		for _, ele := range list {
			inner := tc.convertToDetail("S", ele)
			output = append(output, inner.(string))
		}
		return output
	case "L":
		list := input.([]interface{})
		output := make([]interface{}, 0, len(list))
		for _, ele := range list {
			output = append(output, ele)
		}
		return output
	case "BOOL":
		fallthrough
	case "NULL":
		return input.(bool)
	case "N":
		v := input.(string)

		val_int, err := strconv.Atoi(v)
		if err == nil {
			return val_int
		}

		val, err := primitive.ParseDecimal128(v)
		if err != nil {
			LOG.Error("convert N to decimal128 failed[%v]", err)
			val2, err := strconv.ParseFloat(v, 64)
			if err != nil {
				LOG.Crashf("convert N to decimal128 and float64 both failed[%v]", err)
			}

			val, _ = primitive.ParseDecimal128(fmt.Sprintf("%v", val2))
			return val
		}
		return val
	case "S":
		return input.(string)
	}

	// "M"
	return input
}