578 lines
15 KiB
Go
578 lines
15 KiB
Go
package options
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
|
|
"github.com/spf13/cast"
|
|
)
|
|
|
|
func toInt8SliceE(i interface{}) ([]int8, error) {
|
|
if i == nil {
|
|
return []int8{}, fmt.Errorf("unable to cast %#v of type %T to []int8", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []int8:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]int8, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToInt8E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []int8{}, fmt.Errorf("unable to cast %#v of type %T to []int8", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []int8{}, fmt.Errorf("unable to cast %#v of type %T to []int8", i, i)
|
|
}
|
|
}
|
|
|
|
func toInt16SliceE(i interface{}) ([]int16, error) {
|
|
if i == nil {
|
|
return []int16{}, fmt.Errorf("unable to cast %#v of type %T to []int16", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []int16:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]int16, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToInt16E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []int16{}, fmt.Errorf("unable to cast %#v of type %T to []int16", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []int16{}, fmt.Errorf("unable to cast %#v of type %T to []int16", i, i)
|
|
}
|
|
}
|
|
|
|
func toInt32SliceE(i interface{}) ([]int32, error) {
|
|
if i == nil {
|
|
return []int32{}, fmt.Errorf("unable to cast %#v of type %T to []int32", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []int32:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]int32, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToInt32E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []int32{}, fmt.Errorf("unable to cast %#v of type %T to []int32", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []int32{}, fmt.Errorf("unable to cast %#v of type %T to []int32", i, i)
|
|
}
|
|
}
|
|
|
|
func toInt64SliceE(i interface{}) ([]int64, error) {
|
|
if i == nil {
|
|
return []int64{}, fmt.Errorf("unable to cast %#v of type %T to []int64", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []int64:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]int64, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToInt64E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []int64{}, fmt.Errorf("unable to cast %#v of type %T to []int64", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []int64{}, fmt.Errorf("unable to cast %#v of type %T to []int64", i, i)
|
|
}
|
|
}
|
|
|
|
func toUintSliceE(i interface{}) ([]uint, error) {
|
|
if i == nil {
|
|
return []uint{}, fmt.Errorf("unable to cast %#v of type %T to []uint", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []uint:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]uint, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToUintE(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []uint{}, fmt.Errorf("unable to cast %#v of type %T to []uint", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []uint{}, fmt.Errorf("unable to cast %#v of type %T to []uint", i, i)
|
|
}
|
|
}
|
|
|
|
func toUint8SliceE(i interface{}) ([]uint8, error) {
|
|
if i == nil {
|
|
return []uint8{}, fmt.Errorf("unable to cast %#v of type %T to []uint8", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []uint8:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]uint8, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToUint8E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []uint8{}, fmt.Errorf("unable to cast %#v of type %T to []uint8", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []uint8{}, fmt.Errorf("unable to cast %#v of type %T to []uint8", i, i)
|
|
}
|
|
}
|
|
|
|
func toUint16SliceE(i interface{}) ([]uint16, error) {
|
|
if i == nil {
|
|
return []uint16{}, fmt.Errorf("unable to cast %#v of type %T to []uint16", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []uint16:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]uint16, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToUint16E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []uint16{}, fmt.Errorf("unable to cast %#v of type %T to []uint16", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []uint16{}, fmt.Errorf("unable to cast %#v of type %T to []uint16", i, i)
|
|
}
|
|
}
|
|
|
|
func toUint32SliceE(i interface{}) ([]uint32, error) {
|
|
if i == nil {
|
|
return []uint32{}, fmt.Errorf("unable to cast %#v of type %T to []uint32", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []uint32:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]uint32, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToUint32E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []uint32{}, fmt.Errorf("unable to cast %#v of type %T to []uint32", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []uint32{}, fmt.Errorf("unable to cast %#v of type %T to []uint32", i, i)
|
|
}
|
|
}
|
|
|
|
func toUint64SliceE(i interface{}) ([]uint64, error) {
|
|
if i == nil {
|
|
return []uint64{}, fmt.Errorf("unable to cast %#v of type %T to []uint64", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []uint64:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]uint64, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToUint64E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []uint64{}, fmt.Errorf("unable to cast %#v of type %T to []uint64", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []uint64{}, fmt.Errorf("unable to cast %#v of type %T to []uint64", i, i)
|
|
}
|
|
}
|
|
|
|
func toFloat32SliceE(i interface{}) ([]float32, error) {
|
|
if i == nil {
|
|
return []float32{}, fmt.Errorf("unable to cast %#v of type %T to []float32", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []float32:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]float32, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToFloat32E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []float32{}, fmt.Errorf("unable to cast %#v of type %T to []float32", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []float32{}, fmt.Errorf("unable to cast %#v of type %T to []float32", i, i)
|
|
}
|
|
}
|
|
|
|
func toFloat64SliceE(i interface{}) ([]float64, error) {
|
|
if i == nil {
|
|
return []float64{}, fmt.Errorf("unable to cast %#v of type %T to []float64", i, i)
|
|
}
|
|
|
|
switch v := i.(type) {
|
|
case []float64:
|
|
return v, nil
|
|
}
|
|
|
|
kind := reflect.TypeOf(i).Kind()
|
|
switch kind {
|
|
case reflect.Slice, reflect.Array:
|
|
s := reflect.ValueOf(i)
|
|
a := make([]float64, s.Len())
|
|
for j := 0; j < s.Len(); j++ {
|
|
val, err := cast.ToFloat64E(s.Index(j).Interface())
|
|
if err != nil {
|
|
return []float64{}, fmt.Errorf("unable to cast %#v of type %T to []float64", i, i)
|
|
}
|
|
a[j] = val
|
|
}
|
|
return a, nil
|
|
default:
|
|
return []float64{}, fmt.Errorf("unable to cast %#v of type %T to []float32", i, i)
|
|
}
|
|
}
|
|
|
|
func setMap(src interface{}, dst interface{}) error {
|
|
var err error
|
|
|
|
if src == nil {
|
|
return fmt.Errorf("unable to cast %#v of type %T", src, src)
|
|
}
|
|
if dst == nil {
|
|
return fmt.Errorf("unable to cast %#v of type %T", dst, dst)
|
|
}
|
|
|
|
val := reflect.ValueOf(src)
|
|
|
|
keyKind := val.Type().Key().Kind()
|
|
valKind := val.Type().Elem().Kind()
|
|
|
|
switch v := dst.(type) {
|
|
case []interface{}:
|
|
if len(v) == 1 {
|
|
dstVal := reflect.ValueOf(v[0])
|
|
if dstVal.Kind() != reflect.Map {
|
|
return nil
|
|
}
|
|
mapIter := dstVal.MapRange()
|
|
for mapIter.Next() {
|
|
var (
|
|
keyVal interface{}
|
|
valVal interface{}
|
|
)
|
|
switch keyKind {
|
|
case reflect.Bool:
|
|
keyVal, err = cast.ToBoolE(mapIter.Key())
|
|
case reflect.String:
|
|
keyVal, err = cast.ToStringE(mapIter.Key())
|
|
case reflect.Float32:
|
|
keyVal, err = cast.ToFloat32E(mapIter.Key())
|
|
case reflect.Float64:
|
|
keyVal, err = cast.ToFloat64E(mapIter.Key())
|
|
case reflect.Int8:
|
|
keyVal, err = cast.ToInt8E(mapIter.Key())
|
|
case reflect.Int:
|
|
keyVal, err = cast.ToIntE(mapIter.Key())
|
|
case reflect.Int16:
|
|
keyVal, err = cast.ToInt16E(mapIter.Key())
|
|
case reflect.Int32:
|
|
keyVal, err = cast.ToInt32E(mapIter.Key())
|
|
case reflect.Int64:
|
|
keyVal, err = cast.ToInt64E(mapIter.Key())
|
|
case reflect.Uint8:
|
|
keyVal, err = cast.ToUint8E(mapIter.Key())
|
|
case reflect.Uint:
|
|
keyVal, err = cast.ToUintE(mapIter.Key())
|
|
case reflect.Uint16:
|
|
keyVal, err = cast.ToUint16E(mapIter.Key())
|
|
case reflect.Uint32:
|
|
keyVal, err = cast.ToUint32E(mapIter.Key())
|
|
case reflect.Uint64:
|
|
keyVal, err = cast.ToUint64E(mapIter.Key())
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch valKind {
|
|
case reflect.Bool:
|
|
valVal, err = cast.ToBoolE(mapIter.Value())
|
|
case reflect.String:
|
|
valVal, err = cast.ToStringE(mapIter.Value())
|
|
case reflect.Float32:
|
|
valVal, err = cast.ToFloat32E(mapIter.Value())
|
|
case reflect.Float64:
|
|
valVal, err = cast.ToFloat64E(mapIter.Value())
|
|
case reflect.Int8:
|
|
valVal, err = cast.ToInt8E(mapIter.Value())
|
|
case reflect.Int:
|
|
valVal, err = cast.ToIntE(mapIter.Value())
|
|
case reflect.Int16:
|
|
valVal, err = cast.ToInt16E(mapIter.Value())
|
|
case reflect.Int32:
|
|
valVal, err = cast.ToInt32E(mapIter.Value())
|
|
case reflect.Int64:
|
|
valVal, err = cast.ToInt64E(mapIter.Value())
|
|
case reflect.Uint8:
|
|
valVal, err = cast.ToUint8E(mapIter.Value())
|
|
case reflect.Uint:
|
|
valVal, err = cast.ToUintE(mapIter.Value())
|
|
case reflect.Uint16:
|
|
valVal, err = cast.ToUint16E(mapIter.Value())
|
|
case reflect.Uint32:
|
|
valVal, err = cast.ToUint32E(mapIter.Value())
|
|
case reflect.Uint64:
|
|
valVal, err = cast.ToUint64E(mapIter.Value())
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
val.SetMapIndex(reflect.ValueOf(keyVal), reflect.ValueOf(valVal))
|
|
}
|
|
return nil
|
|
}
|
|
if l := len(v) % 2; l == 1 {
|
|
v = v[:len(v)-1]
|
|
}
|
|
var (
|
|
keyVal interface{}
|
|
valVal interface{}
|
|
)
|
|
for i := 0; i < len(v); i += 2 {
|
|
switch keyKind {
|
|
case reflect.Bool:
|
|
keyVal, err = cast.ToBoolE(v[i])
|
|
case reflect.String:
|
|
keyVal, err = cast.ToStringE(v[i])
|
|
case reflect.Float32:
|
|
keyVal, err = cast.ToFloat32E(v[i])
|
|
case reflect.Float64:
|
|
keyVal, err = cast.ToFloat64E(v[i])
|
|
case reflect.Int8:
|
|
keyVal, err = cast.ToInt8E(v[i])
|
|
case reflect.Int:
|
|
keyVal, err = cast.ToIntE(v[i])
|
|
case reflect.Int16:
|
|
keyVal, err = cast.ToInt16E(v[i])
|
|
case reflect.Int32:
|
|
keyVal, err = cast.ToInt32E(v[i])
|
|
case reflect.Int64:
|
|
keyVal, err = cast.ToInt64E(v[i])
|
|
case reflect.Uint8:
|
|
keyVal, err = cast.ToUint8E(v[i])
|
|
case reflect.Uint:
|
|
keyVal, err = cast.ToUintE(v[i])
|
|
case reflect.Uint16:
|
|
keyVal, err = cast.ToUint16E(v[i])
|
|
case reflect.Uint32:
|
|
keyVal, err = cast.ToUint32E(v[i])
|
|
case reflect.Uint64:
|
|
keyVal, err = cast.ToUint64E(v[i])
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch valKind {
|
|
case reflect.Bool:
|
|
valVal, err = cast.ToBoolE(v[i+1])
|
|
case reflect.String:
|
|
valVal, err = cast.ToStringE(v[i+1])
|
|
case reflect.Float32:
|
|
valVal, err = cast.ToFloat32E(v[i+1])
|
|
case reflect.Float64:
|
|
valVal, err = cast.ToFloat64E(v[i+1])
|
|
case reflect.Int8:
|
|
valVal, err = cast.ToInt8E(v[i+1])
|
|
case reflect.Int:
|
|
valVal, err = cast.ToIntE(v[i+1])
|
|
case reflect.Int16:
|
|
valVal, err = cast.ToInt16E(v[i+1])
|
|
case reflect.Int32:
|
|
valVal, err = cast.ToInt32E(v[i+1])
|
|
case reflect.Int64:
|
|
valVal, err = cast.ToInt64E(v[i+1])
|
|
case reflect.Uint8:
|
|
valVal, err = cast.ToUint8E(v[i+1])
|
|
case reflect.Uint:
|
|
valVal, err = cast.ToUintE(v[i+1])
|
|
case reflect.Uint16:
|
|
valVal, err = cast.ToUint16E(v[i+1])
|
|
case reflect.Uint32:
|
|
valVal, err = cast.ToUint32E(v[i+1])
|
|
case reflect.Uint64:
|
|
valVal, err = cast.ToUint64E(v[i+1])
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
val.SetMapIndex(reflect.ValueOf(keyVal), reflect.ValueOf(valVal))
|
|
}
|
|
default:
|
|
dstVal := reflect.ValueOf(dst)
|
|
if dstVal.Kind() != reflect.Map {
|
|
return nil
|
|
}
|
|
mapIter := dstVal.MapRange()
|
|
for mapIter.Next() {
|
|
var (
|
|
keyVal interface{}
|
|
valVal interface{}
|
|
)
|
|
switch keyKind {
|
|
case reflect.Bool:
|
|
keyVal, err = cast.ToBoolE(mapIter.Key())
|
|
case reflect.String:
|
|
keyVal, err = cast.ToStringE(mapIter.Key())
|
|
case reflect.Float32:
|
|
keyVal, err = cast.ToFloat32E(mapIter.Key())
|
|
case reflect.Float64:
|
|
keyVal, err = cast.ToFloat64E(mapIter.Key())
|
|
case reflect.Int8:
|
|
keyVal, err = cast.ToInt8E(mapIter.Key())
|
|
case reflect.Int:
|
|
keyVal, err = cast.ToIntE(mapIter.Key())
|
|
case reflect.Int16:
|
|
keyVal, err = cast.ToInt16E(mapIter.Key())
|
|
case reflect.Int32:
|
|
keyVal, err = cast.ToInt32E(mapIter.Key())
|
|
case reflect.Int64:
|
|
keyVal, err = cast.ToInt64E(mapIter.Key())
|
|
case reflect.Uint8:
|
|
keyVal, err = cast.ToUint8E(mapIter.Key())
|
|
case reflect.Uint:
|
|
keyVal, err = cast.ToUintE(mapIter.Key())
|
|
case reflect.Uint16:
|
|
keyVal, err = cast.ToUint16E(mapIter.Key())
|
|
case reflect.Uint32:
|
|
keyVal, err = cast.ToUint32E(mapIter.Key())
|
|
case reflect.Uint64:
|
|
keyVal, err = cast.ToUint64E(mapIter.Key())
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch valKind {
|
|
case reflect.Bool:
|
|
valVal, err = cast.ToBoolE(mapIter.Value())
|
|
case reflect.String:
|
|
valVal, err = cast.ToStringE(mapIter.Value())
|
|
case reflect.Float32:
|
|
valVal, err = cast.ToFloat32E(mapIter.Value())
|
|
case reflect.Float64:
|
|
valVal, err = cast.ToFloat64E(mapIter.Value())
|
|
case reflect.Int8:
|
|
valVal, err = cast.ToInt8E(mapIter.Value())
|
|
case reflect.Int:
|
|
valVal, err = cast.ToIntE(mapIter.Value())
|
|
case reflect.Int16:
|
|
valVal, err = cast.ToInt16E(mapIter.Value())
|
|
case reflect.Int32:
|
|
valVal, err = cast.ToInt32E(mapIter.Value())
|
|
case reflect.Int64:
|
|
valVal, err = cast.ToInt64E(mapIter.Value())
|
|
case reflect.Uint8:
|
|
valVal, err = cast.ToUint8E(mapIter.Value())
|
|
case reflect.Uint:
|
|
valVal, err = cast.ToUintE(mapIter.Value())
|
|
case reflect.Uint16:
|
|
valVal, err = cast.ToUint16E(mapIter.Value())
|
|
case reflect.Uint32:
|
|
valVal, err = cast.ToUint32E(mapIter.Value())
|
|
case reflect.Uint64:
|
|
valVal, err = cast.ToUint64E(mapIter.Value())
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
val.SetMapIndex(reflect.ValueOf(keyVal), reflect.ValueOf(valVal))
|
|
}
|
|
return nil
|
|
}
|
|
return nil
|
|
}
|