GaoreGo/cast
8
0
Fork 0
Code Releases 1 Activity

Add map of int64 and map of int

Browse Source
This commit is contained in:
Theo 2018-10-10 15:13:50 +01:00
parent 8965335b8c
commit 0744dd163e
3 changed files with 271 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
cast.go
View File

@ -122,6 +122,18 @@ func ToStringMapBool(i interface{}) map[string]bool {
return v
}
// ToStringMapInt casts an interface to a map[string]int type.
func ToStringMapInt(i interface{}) map[string]int {
v, _ := ToStringMapIntE(i)
return v
}
// ToStringMapInt64 casts an interface to a map[string]int64 type.
func ToStringMapInt64(i interface{}) map[string]int64 {
v, _ := ToStringMapInt64E(i)
return v
}
// ToStringMap casts an interface to a map[string]interface{} type.
func ToStringMap(i interface{}) map[string]interface{} {
v, _ := ToStringMapE(i)

77
cast_test.go
View File

@ -821,6 +821,83 @@ func TestToStringMapBoolE(t *testing.T) {
}
}
func TestToStringMapIntE(t *testing.T) {
tests := []struct {
input interface{}
expect map[string]int
iserr bool
}{
{map[interface{}]interface{}{"v1": 1, "v2": 222}, map[string]int{"v1": 1, "v2": 222}, false},
{map[string]interface{}{"v1": 342, "v2": 5141}, map[string]int{"v1": 342, "v2": 5141}, false},
{map[string]int{"v1": 33, "v2": 88}, map[string]int{"v1": 33, "v2": 88}, false},
{map[string]int32{"v1": int32(33), "v2": int32(88)}, map[string]int{"v1": 33, "v2": 88}, false},
{map[string]uint16{"v1": uint16(33), "v2": uint16(88)}, map[string]int{"v1": 33, "v2": 88}, false},
{map[string]float64{"v1": float64(8.22), "v2": float64(43.32)}, map[string]int{"v1": 8, "v2": 43}, false},
{`{"v1": 67, "v2": 56}`, map[string]int{"v1": 67, "v2": 56}, false},
// errors
{nil, nil, true},
{testing.T{}, nil, true},
{"", nil, true},
}
for i, test := range tests {
errmsg := fmt.Sprintf("i = %d", i) // assert helper message
v, err := ToStringMapIntE(test.input)
if test.iserr {
assert.Error(t, err, errmsg)
continue
}
assert.NoError(t, err, errmsg)
assert.Equal(t, test.expect, v, errmsg)
// Non-E test
v = ToStringMapInt(test.input)
assert.Equal(t, test.expect, v, errmsg)
}
}
func TestToStringMapInt64E(t *testing.T) {
tests := []struct {
input interface{}
expect map[string]int64
iserr bool
}{
{map[interface{}]interface{}{"v1": int32(8), "v2": int32(888)}, map[string]int64{"v1": int64(8), "v2": int64(888)}, false},
{map[string]interface{}{"v1": int64(45), "v2": int64(67)}, map[string]int64{"v1": 45, "v2": 67}, false},
{map[string]int64{"v1": 33, "v2": 88}, map[string]int64{"v1": 33, "v2": 88}, false},
{map[string]int{"v1": 33, "v2": 88}, map[string]int64{"v1": 33, "v2": 88}, false},
{map[string]int32{"v1": int32(33), "v2": int32(88)}, map[string]int64{"v1": 33, "v2": 88}, false},
{map[string]uint16{"v1": uint16(33), "v2": uint16(88)}, map[string]int64{"v1": 33, "v2": 88}, false},
{map[string]float64{"v1": float64(8.22), "v2": float64(43.32)}, map[string]int64{"v1": 8, "v2": 43}, false},
{`{"v1": 67, "v2": 56}`, map[string]int64{"v1": 67, "v2": 56}, false},
// errors
{nil, nil, true},
{testing.T{}, nil, true},
{"", nil, true},
}
for i, test := range tests {
errmsg := fmt.Sprintf("i = %d", i) // assert helper message
v, err := ToStringMapInt64E(test.input)
if test.iserr {
assert.Error(t, err, errmsg)
continue
}
assert.NoError(t, err, errmsg)
assert.Equal(t, test.expect, v, errmsg)
// Non-E test
v = ToStringMapInt64(test.input)
assert.Equal(t, test.expect, v, errmsg)
}
}
func TestToStringMapStringE(t *testing.T) {
var stringMapString = map[string]string{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
var stringMapInterface = map[string]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}

182
caste.go
View File

@ -990,6 +990,188 @@ func ToStringMapE(i interface{}) (map[string]interface{}, error) {
}
}
// ToStringMapIntE casts an interface to a map[string]int{} type.
func ToStringMapIntE(i interface{}) (map[string]int, error) {
var m = map[string]int{}
if i == nil {
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i)
}
switch v := i.(type) {
case map[interface{}]interface{}:
for k, val := range v {
m[ToString(k)] = ToInt(val)
}
return m, nil
case map[string]interface{}:
for k, val := range v {
m[k] = ToInt(val)
}
return m, nil
case map[string]int:
return v, nil
case string:
err := jsonStringToObject(v, &m)
return m, err
}
if reflect.TypeOf(i).Kind() != reflect.Map {
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i)
}
kind := reflect.TypeOf(i).Elem().Kind()
switch kind {
case reflect.Int8:
for k, val := range i.(map[string]int8) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Int16:
for k, val := range i.(map[string]int16) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Int32:
for k, val := range i.(map[string]int32) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Int64:
for k, val := range i.(map[string]int64) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Uint:
for k, val := range i.(map[string]uint) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Uint8:
for k, val := range i.(map[string]uint8) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Uint16:
for k, val := range i.(map[string]uint16) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Uint32:
for k, val := range i.(map[string]uint32) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Float32:
for k, val := range i.(map[string]float32) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Float64:
for k, val := range i.(map[string]float64) {
m[k] = ToInt(val)
}
return m, nil
case reflect.Bool:
for k, val := range i.(map[string]bool) {
m[k] = ToInt(val)
}
return m, nil
default:
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i)
}
}
// ToStringMapInt64E casts an interface to a map[string]int64{} type.
func ToStringMapInt64E(i interface{}) (map[string]int64, error) {
var m = map[string]int64{}
if i == nil {
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i)
}
switch v := i.(type) {
case map[interface{}]interface{}:
for k, val := range v {
m[ToString(k)] = ToInt64(val)
}
return m, nil
case map[string]interface{}:
for k, val := range v {
m[k] = ToInt64(val)
}
return m, nil
case map[string]int64:
return v, nil
case string:
err := jsonStringToObject(v, &m)
return m, err
}
if reflect.TypeOf(i).Kind() != reflect.Map {
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i)
}
kind := reflect.TypeOf(i).Elem().Kind()
switch kind {
case reflect.Int8:
for k, val := range i.(map[string]int8) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Int16:
for k, val := range i.(map[string]int16) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Int32:
for k, val := range i.(map[string]int32) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Int:
for k, val := range i.(map[string]int) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Uint:
for k, val := range i.(map[string]uint) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Uint8:
for k, val := range i.(map[string]uint8) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Uint16:
for k, val := range i.(map[string]uint16) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Uint32:
for k, val := range i.(map[string]uint32) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Float32:
for k, val := range i.(map[string]float32) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Float64:
for k, val := range i.(map[string]float64) {
m[k] = ToInt64(val)
}
return m, nil
case reflect.Bool:
for k, val := range i.(map[string]bool) {
m[k] = ToInt64(val)
}
return m, nil
default:
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i)
}
}
// ToSliceE casts an interface to a []interface{} type.
func ToSliceE(i interface{}) ([]interface{}, error) {
var s []interface{}