type_assert.go

Documentation: github.com/ory/x/mapx

     1  package mapx
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"fmt"
     7  	"time"
     8  )
     9  
    10  // ErrKeyDoesNotExist is returned when the key does not exist in the map.
    11  var ErrKeyDoesNotExist = errors.New("key is not present in map")
    12  
    13  // ErrKeyCanNotBeTypeAsserted is returned when the key can not be type asserted.
    14  var ErrKeyCanNotBeTypeAsserted = errors.New("key could not be type asserted")
    15  
    16  // GetString returns a string for a given key in values.
    17  func GetString(values map[interface{}]interface{}, key interface{}) (string, error) {
    18  	if v, ok := values[key]; !ok {
    19  		return "", ErrKeyDoesNotExist
    20  	} else if sv, ok := v.(string); !ok {
    21  		return "", ErrKeyCanNotBeTypeAsserted
    22  	} else {
    23  		return sv, nil
    24  	}
    25  }
    26  
    27  // GetStringSlice returns a string slice for a given key in values.
    28  func GetStringSlice(values map[interface{}]interface{}, key interface{}) ([]string, error) {
    29  	if v, ok := values[key]; !ok {
    30  		return []string{}, ErrKeyDoesNotExist
    31  	} else if sv, ok := v.([]string); ok {
    32  		return sv, nil
    33  	} else if sv, ok := v.([]interface{}); ok {
    34  		vs := make([]string, len(sv))
    35  		for k, v := range sv {
    36  			vv, ok := v.(string)
    37  			if !ok {
    38  				return []string{}, ErrKeyCanNotBeTypeAsserted
    39  			}
    40  			vs[k] = vv
    41  		}
    42  		return vs, nil
    43  	}
    44  	return []string{}, ErrKeyCanNotBeTypeAsserted
    45  }
    46  
    47  // GetTime returns a string slice for a given key in values.
    48  func GetTime(values map[interface{}]interface{}, key interface{}) (time.Time, error) {
    49  	v, ok := values[key]
    50  	if !ok {
    51  		return time.Time{}, ErrKeyDoesNotExist
    52  	}
    53  
    54  	if sv, ok := v.(time.Time); ok {
    55  		return sv, nil
    56  	} else if sv, ok := v.(int64); ok {
    57  		return time.Unix(sv, 0), nil
    58  	} else if sv, ok := v.(int32); ok {
    59  		return time.Unix(int64(sv), 0), nil
    60  	} else if sv, ok := v.(int); ok {
    61  		return time.Unix(int64(sv), 0), nil
    62  	} else if sv, ok := v.(float64); ok {
    63  		return time.Unix(int64(sv), 0), nil
    64  	} else if sv, ok := v.(float32); ok {
    65  		return time.Unix(int64(sv), 0), nil
    66  	}
    67  
    68  	return time.Time{}, ErrKeyCanNotBeTypeAsserted
    69  }
    70  
    71  // GetInt64Default returns a int64 or the default value for a given key in values.
    72  func GetInt64Default(values map[interface{}]interface{}, key interface{}, defaultValue int64) int64 {
    73  	f, err := GetInt64(values, key)
    74  	if err != nil {
    75  		return defaultValue
    76  	}
    77  	return f
    78  }
    79  
    80  // GetInt64 returns an int64 for a given key in values.
    81  func GetInt64(values map[interface{}]interface{}, key interface{}) (int64, error) {
    82  	if v, ok := values[key]; !ok {
    83  		return 0, ErrKeyDoesNotExist
    84  	} else if j, ok := v.(json.Number); ok {
    85  		return j.Int64()
    86  	} else if sv, ok := v.(int64); ok {
    87  		return sv, nil
    88  	}
    89  	return 0, ErrKeyCanNotBeTypeAsserted
    90  }
    91  
    92  // GetInt32Default returns a int32 or the default value for a given key in values.
    93  func GetInt32Default(values map[interface{}]interface{}, key interface{}, defaultValue int32) int32 {
    94  	f, err := GetInt32(values, key)
    95  	if err != nil {
    96  		return defaultValue
    97  	}
    98  	return f
    99  }
   100  
   101  // GetInt32 returns an int32 for a given key in values.
   102  func GetInt32(values map[interface{}]interface{}, key interface{}) (int32, error) {
   103  	if v, ok := values[key]; !ok {
   104  		return 0, ErrKeyDoesNotExist
   105  	} else if sv, ok := v.(int32); ok {
   106  		return sv, nil
   107  	} else if sv, ok := v.(int); ok {
   108  		return int32(sv), nil
   109  	} else if j, ok := v.(json.Number); ok {
   110  		v, err := j.Int64()
   111  		return int32(v), err
   112  	}
   113  	return 0, ErrKeyCanNotBeTypeAsserted
   114  }
   115  
   116  // GetIntDefault returns a int or the default value for a given key in values.
   117  func GetIntDefault(values map[interface{}]interface{}, key interface{}, defaultValue int) int {
   118  	f, err := GetInt(values, key)
   119  	if err != nil {
   120  		return defaultValue
   121  	}
   122  	return f
   123  }
   124  
   125  // GetInt returns an int for a given key in values.
   126  func GetInt(values map[interface{}]interface{}, key interface{}) (int, error) {
   127  	if v, ok := values[key]; !ok {
   128  		return 0, ErrKeyDoesNotExist
   129  	} else if sv, ok := v.(int32); ok {
   130  		return int(sv), nil
   131  	} else if sv, ok := v.(int); ok {
   132  		return sv, nil
   133  	} else if j, ok := v.(json.Number); ok {
   134  		v, err := j.Int64()
   135  		return int(v), err
   136  	}
   137  	return 0, ErrKeyCanNotBeTypeAsserted
   138  
   139  }
   140  
   141  // GetFloat32Default returns a float32 or the default value for a given key in values.
   142  func GetFloat32Default(values map[interface{}]interface{}, key interface{}, defaultValue float32) float32 {
   143  	f, err := GetFloat32(values, key)
   144  	if err != nil {
   145  		return defaultValue
   146  	}
   147  	return f
   148  }
   149  
   150  // GetFloat32 returns a float32 for a given key in values.
   151  func GetFloat32(values map[interface{}]interface{}, key interface{}) (float32, error) {
   152  	if v, ok := values[key]; !ok {
   153  		return 0, ErrKeyDoesNotExist
   154  	} else if j, ok := v.(json.Number); ok {
   155  		v, err := j.Float64()
   156  		return float32(v), err
   157  	} else if sv, ok := v.(float32); ok {
   158  		return sv, nil
   159  	}
   160  	return 0, ErrKeyCanNotBeTypeAsserted
   161  }
   162  
   163  // GetFloat64Default returns a float64 or the default value for a given key in values.
   164  func GetFloat64Default(values map[interface{}]interface{}, key interface{}, defaultValue float64) float64 {
   165  	f, err := GetFloat64(values, key)
   166  	if err != nil {
   167  		return defaultValue
   168  	}
   169  	return f
   170  }
   171  
   172  // GetFloat64 returns a float64 for a given key in values.
   173  func GetFloat64(values map[interface{}]interface{}, key interface{}) (float64, error) {
   174  	if v, ok := values[key]; !ok {
   175  		return 0, ErrKeyDoesNotExist
   176  	} else if j, ok := v.(json.Number); ok {
   177  		return j.Float64()
   178  	} else if sv, ok := v.(float64); ok {
   179  		return sv, nil
   180  	}
   181  	return 0, ErrKeyCanNotBeTypeAsserted
   182  }
   183  
   184  // GetStringDefault returns a string or the default value for a given key in values.
   185  func GetStringDefault(values map[interface{}]interface{}, key interface{}, defaultValue string) string {
   186  	if s, err := GetString(values, key); err == nil {
   187  		return s
   188  	}
   189  	return defaultValue
   190  }
   191  
   192  // GetStringSliceDefault returns a string slice or the default value for a given key in values.
   193  func GetStringSliceDefault(values map[interface{}]interface{}, key interface{}, defaultValue []string) []string {
   194  	if s, err := GetStringSlice(values, key); err == nil {
   195  		return s
   196  	}
   197  	return defaultValue
   198  }
   199  
   200  // KeyStringToInterface converts map[string]interface{} to map[interface{}]interface{}
   201  func KeyStringToInterface(i map[string]interface{}) map[interface{}]interface{} {
   202  	o := make(map[interface{}]interface{})
   203  	for k, v := range i {
   204  		o[k] = v
   205  	}
   206  	return o
   207  }
   208  
   209  // ToJSONMap converts all map[interface{}]interface{} occurrences (nested as well) to map[string]interface{}.
   210  func ToJSONMap(i interface{}) interface{} {
   211  	switch t := i.(type) {
   212  	case []interface{}:
   213  		for k, v := range t {
   214  			t[k] = ToJSONMap(v)
   215  		}
   216  		return t
   217  	case map[string]interface{}:
   218  		for k, v := range t {
   219  			t[k] = ToJSONMap(v)
   220  		}
   221  		return t
   222  	case map[interface{}]interface{}:
   223  		res := make(map[string]interface{})
   224  		for k, v := range t {
   225  			res[fmt.Sprintf("%s", k)] = ToJSONMap(v)
   226  		}
   227  		return res
   228  	}
   229  
   230  	return i
   231  }
   232
View as plain text