Merge pull request #9203 from matejvasek/improve_param_serder_generator

[NO TESTS NEEDED] Improve binding generator

pkg/bindings/containers/types_attach_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *AttachOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *AttachOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_checkpoint_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *CheckpointOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *CheckpointOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_commit_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *CommitOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *CommitOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_create_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_diff_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *DiffOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *DiffOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_execinspect_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExecInspectOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExecInspectOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_execstart_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExecStartOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExecStartOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_execstartandattach_options.go

@@ -5,9 +5,9 @@ import (
 	"io"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -45,33 +45,19 @@ func (o *ExecStartAndAttachOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -85,6 +71,7 @@ func (o *ExecStartAndAttachOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_exists_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_export_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExportOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExportOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_healthcheck_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *HealthCheckOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *HealthCheckOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_init_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *InitOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *InitOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_inspect_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_kill_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *KillOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *KillOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_list_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_log_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *LogOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *LogOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_mount_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *MountOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *MountOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_mountedcontainerpaths_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *MountedContainerPathsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *MountedContainerPathsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_pause_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PauseOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PauseOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_prune_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_remove_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_rename_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RenameOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RenameOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_resizeexectty_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ResizeExecTTYOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ResizeExecTTYOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_resizetty_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ResizeTTYOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ResizeTTYOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_restart_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RestartOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RestartOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_restore_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RestoreOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RestoreOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_shouldrestart_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ShouldRestartOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ShouldRestartOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_start_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *StartOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *StartOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_stats_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *StatsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *StatsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_stop_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *StopOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *StopOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_top_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *TopOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *TopOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_unmount_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *UnmountOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *UnmountOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_unpause_options.go

@@ -3,9 +3,9 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *UnpauseOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *UnpauseOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/containers/types_wait_options.go

@@ -3,10 +3,10 @@ package containers
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
 	"github.com/containers/podman/v2/libpod/define"
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -44,33 +44,19 @@ func (o *WaitOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -84,6 +70,7 @@ func (o *WaitOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/generate/types_kube_options.go

@@ -1,13 +1,13 @@
 package generate
 
 import (
+	"errors"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 )
 
 /*
@@ -43,33 +43,19 @@ func (o *KubeOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *KubeOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/generate/types_systemd_options.go

@@ -1,13 +1,13 @@
 package generate
 
 import (
+	"errors"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 )
 
 /*
@@ -43,33 +43,19 @@ func (o *SystemdOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *SystemdOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/generator/generator.go

@@ -54,33 +54,19 @@ func (o *{{.StructName}}) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -94,6 +80,7 @@ func (o *{{.StructName}}) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }
@@ -144,7 +131,7 @@ func main() {
 		panic(err)
 	}
 	// always add reflect
-	imports := []string{"\"reflect\""}
+	imports := []string{"\"reflect\"", "\"github.com/containers/podman/v2/pkg/bindings/util\""}
 	for _, imp := range f.Imports {
 		imports = append(imports, imp.Path.Value)
 	}

pkg/bindings/images/types_diff_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *DiffOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *DiffOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_exists_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_export_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExportOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExportOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_get_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *GetOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *GetOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_history_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *HistoryOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *HistoryOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_import_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ImportOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ImportOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_list_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_load_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *LoadOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *LoadOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_prune_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_pull_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PullOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PullOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_push_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PushOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PushOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_remove_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_search_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *SearchOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *SearchOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_tag_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *TagOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *TagOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_tree_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *TreeOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *TreeOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/images/types_untag_options.go

@@ -3,9 +3,9 @@ package images
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *UntagOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *UntagOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/manifests/types_add_options.go

@@ -1,13 +1,13 @@
 package manifests
 
 import (
+	"errors"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 )
 
 /*
@@ -43,33 +43,19 @@ func (o *AddOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *AddOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/manifests/types_create_options.go

@@ -1,13 +1,13 @@
 package manifests
 
 import (
+	"errors"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 )
 
 /*
@@ -43,33 +43,19 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/manifests/types_exists_options.go

@@ -1,13 +1,13 @@
 package manifests
 
 import (
+	"errors"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 )
 
 /*
@@ -43,33 +43,19 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/manifests/types_inspect_options.go

@@ -1,13 +1,13 @@
 package manifests
 
 import (
+	"errors"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 )
 
 /*
@@ -43,33 +43,19 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/manifests/types_remove_options.go

@@ -1,13 +1,13 @@
 package manifests
 
 import (
+	"errors"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 )
 
 /*
@@ -43,33 +43,19 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/network/types_connect_options.go

@@ -3,9 +3,9 @@ package network
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ConnectOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ConnectOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/network/types_create_options.go

@@ -4,9 +4,9 @@ import (
 	"net"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -44,33 +44,19 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -84,6 +70,7 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/network/types_disconnect_options.go

@@ -3,9 +3,9 @@ package network
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *DisconnectOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *DisconnectOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/network/types_exists_options.go

@@ -3,9 +3,9 @@ package network
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/network/types_inspect_options.go

@@ -3,9 +3,9 @@ package network
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/network/types_list_options.go

@@ -3,9 +3,9 @@ package network
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/network/types_remove_options.go

@@ -3,9 +3,9 @@ package network
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/play/types_kube_options.go

@@ -1,13 +1,13 @@
 package play
 
 import (
+	"errors"
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 )
 
 /*
@@ -43,33 +43,19 @@ func (o *KubeOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *KubeOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_create_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_exists_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_inspect_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_kill_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *KillOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *KillOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_list_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_pause_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PauseOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PauseOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_prune_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_remove_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_restart_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RestartOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RestartOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_start_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *StartOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *StartOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_stats_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *StatsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *StatsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_stop_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *StopOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *StopOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_top_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *TopOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *TopOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/pods/types_unpause_options.go

@@ -3,9 +3,9 @@ package pods
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *UnpauseOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *UnpauseOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/system/types_disk_options.go

@@ -3,9 +3,9 @@ package system
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *DiskOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *DiskOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/system/types_events_options.go

@@ -3,9 +3,9 @@ package system
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *EventsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *EventsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/system/types_info_options.go

@@ -3,9 +3,9 @@ package system
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *InfoOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *InfoOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/system/types_prune_options.go

@@ -3,9 +3,9 @@ package system
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/system/types_version_options.go

@@ -3,9 +3,9 @@ package system
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *VersionOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *VersionOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/util/util.go

@@ -0,0 +1,30 @@
+package util
+
+import (
+	"reflect"
+	"strconv"
+)
+
+func IsSimpleType(f reflect.Value) bool {
+	switch f.Kind() {
+	case reflect.Bool, reflect.Int, reflect.Int64, reflect.Uint, reflect.Uint64, reflect.String:
+		return true
+	}
+	return false
+}
+
+func SimpleTypeToParam(f reflect.Value) string {
+	switch f.Kind() {
+	case reflect.Bool:
+		return strconv.FormatBool(f.Bool())
+	case reflect.Int, reflect.Int64:
+		// f.Int() is always an int64
+		return strconv.FormatInt(f.Int(), 10)
+	case reflect.Uint, reflect.Uint64:
+		// f.Uint() is always an uint64
+		return strconv.FormatUint(f.Uint(), 10)
+	case reflect.String:
+		return f.String()
+	}
+	panic("the input parameter is not a simple type")
+}

pkg/bindings/volumes/types_create_options.go

@@ -3,9 +3,9 @@ package volumes
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *CreateOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/volumes/types_exists_options.go

@@ -3,9 +3,9 @@ package volumes
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ExistsOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/volumes/types_inspect_options.go

@@ -3,9 +3,9 @@ package volumes
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *InspectOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/volumes/types_list_options.go

@@ -3,9 +3,9 @@ package volumes
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *ListOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/volumes/types_prune_options.go

@@ -3,9 +3,9 @@ package volumes
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *PruneOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }

pkg/bindings/volumes/types_remove_options.go

@@ -3,9 +3,9 @@ package volumes
 import (
 	"net/url"
 	"reflect"
-	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/pkg/bindings/util"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
 )
@@ -43,33 +43,19 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 		if reflect.Ptr == f.Kind() {
 			f = f.Elem()
 		}
-		switch f.Kind() {
+		switch {
-		case reflect.Bool:
+		case util.IsSimpleType(f):
-			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+			params.Set(fieldName, util.SimpleTypeToParam(f))
-		case reflect.String:
+		case f.Kind() == reflect.Slice:
-			params.Set(fieldName, f.String())
+			for i := 0; i < f.Len(); i++ {
-		case reflect.Int, reflect.Int64:
+				elem := f.Index(i)
-			// f.Int() is always an int64
+				if util.IsSimpleType(elem) {
-			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+					params.Add(fieldName, util.SimpleTypeToParam(elem))
-		case reflect.Uint, reflect.Uint64:
+				} else {
-			// f.Uint() is always an uint64
+					return nil, errors.New("slices must contain only simple types")
-			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
-		case reflect.Slice:
-			typ := reflect.TypeOf(f.Interface()).Elem()
-			switch typ.Kind() {
-			case reflect.String:
-				sl := f.Slice(0, f.Len())
-				s, ok := sl.Interface().([]string)
-				if !ok {
-					return nil, errors.New("failed to convert to string slice")
 				}
-				for _, val := range s {
-					params.Add(fieldName, val)
 			}
-			default:
+		case f.Kind() == reflect.Map:
-				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
-			}
-		case reflect.Map:
 			lowerCaseKeys := make(map[string][]string)
 			iter := f.MapRange()
 			for iter.Next() {
@@ -83,6 +69,7 @@ func (o *RemoveOptions) ToParams() (url.Values, error) {
 
 			params.Set(fieldName, s)
 		}
+
 	}
 	return params, nil
 }