switches getEnv to generic

internal/config/envconfig.go

@@ -21,79 +21,47 @@ type structInfo struct {
 	Secret       interface{}
 }
 
-// getEnvString returns string from environment variable
+func getEnv[t string | bool | int | int64 | float64](env string, def t) (t, error) {
-func getEnvString(env string, def string) string {
 	val := os.Getenv(env)
-
-	if len(val) == 0 {
-		return def
-	}
-
-	return ""
-}
-
-// getEnvBool returns boolean from environment variable
-func getEnvBool(env string, def bool) (bool, error) {
-	val := os.Getenv(env)
-
 	if len(val) == 0 {
 		return def, nil
 	}
 
-	ret, err := strconv.ParseBool(val)
+	output := *new(t)
+	switch (interface{})(def).(type) {
+	case string:
+		v, err := typeConversion("string", val)
 		if err != nil {
-		return false, fmt.Errorf("Environment variable is not of type bool: %v", env)
+			return (interface{})(false).(t), err
 		}
-
+		output = v.(t)
-	return ret, nil
+	case bool:
-}
+		v, err := typeConversion("bool", val)
-
-// getEnvInt returns int from environment variable
-func getEnvInt(env string, def int) (int, error) {
-	val := os.Getenv(env)
-
-	if len(val) == 0 {
-		return def, nil
-	}
-
-	ret, err := strconv.Atoi(val)
 		if err != nil {
-		return 0, fmt.Errorf("Environment variable is not of type int: %v", env)
+			return (interface{})(false).(t), err
 		}
-
+		output = v.(t)
-	return ret, nil
+	case int:
-}
+		v, err := typeConversion("int", val)
-
-// getEnvInt64 return int64 from environment variable
-func getEnvInt64(env string, def int64) (int64, error) {
-	val := os.Getenv(env)
-
-	if len(val) == 0 {
-		return def, nil
-	}
-
-	ret, err := strconv.ParseInt(val, 10, 64)
 		if err != nil {
-		return 0, fmt.Errorf("Environment variable is not of type int64: %v", env)
+			return (interface{})(int(0)).(t), err
 		}
-
+		output = (interface{})(v.(int)).(t)
-	return ret, nil
+	case int64:
-}
+		v, err := typeConversion("int64", val)
-
-// getEnvFloat64 return float64 from environment variable
-func getEnvFloat64(env string, def float64) (float64, error) {
-	val := os.Getenv(env)
-
-	if len(val) == 0 {
-		return def, nil
-	}
-
-	ret, err := strconv.ParseFloat(val, 64)
 		if err != nil {
-		return 0, fmt.Errorf("Environment variable is not of type float64: %v", env)
+			return (interface{})(int64(0)).(t), err
+		}
+		output = v.(t)
+	case float64:
+		v, err := typeConversion("float64", val)
+		if err != nil {
+			return (interface{})(float64(0)).(t), err
+		}
+		output = v.(t)
 	}
 
-	return ret, nil
+	return output, nil
 }
 
 func getStructInfo(spec interface{}) ([]structInfo, error) {
@@ -213,7 +181,11 @@ func (cfg *Config) parseFlags(cfgInfo []structInfo) error {
 				dv = info.DefaultValue.(string)
 			}
 			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*string)
-			flag.StringVar(p, info.Name, getEnvString(info.Alt, dv), info.Info)
+			retVal, err := getEnv(info.Alt, dv)
+			if err != nil {
+				return err
+			}
+			flag.StringVar(p, info.Name, retVal, info.Info)
 		case "bool":
 			var dv bool
 
@@ -221,7 +193,7 @@ func (cfg *Config) parseFlags(cfgInfo []structInfo) error {
 				dv = info.DefaultValue.(bool)
 			}
 			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*bool)
-			retVal, err := getEnvBool(info.Alt, dv)
+			retVal, err := getEnv(info.Alt, dv)
 			if err != nil {
 				return err
 			}
@@ -233,7 +205,7 @@ func (cfg *Config) parseFlags(cfgInfo []structInfo) error {
 				dv = int(info.DefaultValue.(int64))
 			}
 			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*int)
-			retVal, err := getEnvInt(info.Alt, dv)
+			retVal, err := getEnv(info.Alt, dv)
 			if err != nil {
 				return err
 			}
@@ -245,7 +217,7 @@ func (cfg *Config) parseFlags(cfgInfo []structInfo) error {
 				dv = info.DefaultValue.(int64)
 			}
 			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*int64)
-			retVal, err := getEnvInt64(info.Alt, dv)
+			retVal, err := getEnv(info.Alt, dv)
 			if err != nil {
 				return err
 			}
@@ -257,7 +229,7 @@ func (cfg *Config) parseFlags(cfgInfo []structInfo) error {
 				dv = info.DefaultValue.(float64)
 			}
 			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*float64)
-			retVal, err := getEnvFloat64(info.Alt, dv)
+			retVal, err := getEnv(info.Alt, dv)
 			if err != nil {
 				return err
 			}