-
Notifications
You must be signed in to change notification settings - Fork 13
/
util.go
129 lines (116 loc) · 2.78 KB
/
util.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// Utility functions for plugins.
package goma
const (
// EPSILON is permitted error for float comparison.
EPSILON = 0.00000001
)
// FloatEquals compares two floats allowing error within EPSILON.
func FloatEquals(a, b float64) bool {
if a == b {
return true
}
return (a-b) < EPSILON && (b-a) < EPSILON
}
// GetBool extracts a boolean from TOML decoded map.
// If m[key] does not exist or is not a bool, non-nil error is returned.
func GetBool(key string, m map[string]interface{}) (bool, error) {
v, ok := m[key]
if !ok {
return false, ErrNoKey
}
b, ok := v.(bool)
if !ok {
return false, ErrInvalidType
}
return b, nil
}
// GetInt extracts an integer from TOML decoded map.
// If m[key] does not exist or is not an integer, non-nil error is returned.
func GetInt(key string, m map[string]interface{}) (int, error) {
v, ok := m[key]
if !ok {
return 0, ErrNoKey
}
i, ok := v.(int)
if !ok {
return 0, ErrInvalidType
}
return i, nil
}
// GetFloat extracts a float from TOML decoded map.
// If m[key] does not exist or is not a float/int, non-nil error is returned.
func GetFloat(key string, m map[string]interface{}) (float64, error) {
v, ok := m[key]
if !ok {
return 0, ErrNoKey
}
switch v := v.(type) {
case float64:
return v, nil
case int:
return float64(v), nil
default:
return 0, ErrInvalidType
}
}
// GetString extracts a string from TOML decoded map.
// If m[key] does not exist or is not a string, non-nil error is returned.
func GetString(key string, m map[string]interface{}) (string, error) {
v, ok := m[key]
if !ok {
return "", ErrNoKey
}
s, ok := v.(string)
if !ok {
return "", ErrInvalidType
}
return s, nil
}
// GetStringList constructs a string list from TOML decoded map.
// If m[key] does not exist or is not a string list, non-nil error is returned.
func GetStringList(key string, m map[string]interface{}) ([]string, error) {
v, ok := m[key]
if !ok {
return nil, ErrNoKey
}
if sl, ok := v.([]string); ok {
return sl, nil
}
l, ok := v.([]interface{})
if !ok {
return nil, ErrInvalidType
}
ret := make([]string, 0, len(l))
for _, t := range l {
s, ok := t.(string)
if !ok {
return nil, ErrInvalidType
}
ret = append(ret, s)
}
return ret, nil
}
// GetStringMap constructs a map[string]string from TOML decoded map.
// If m[key] does not exist or is not a string map, non-nil error is returned.
func GetStringMap(key string, m map[string]interface{}) (map[string]string, error) {
v, ok := m[key]
if !ok {
return nil, ErrNoKey
}
if sm, ok := v.(map[string]string); ok {
return sm, nil
}
m2, ok := v.(map[string]interface{})
if !ok {
return nil, ErrInvalidType
}
ret := make(map[string]string)
for k, v2 := range m2 {
s, ok := v2.(string)
if !ok {
return nil, ErrInvalidType
}
ret[k] = s
}
return ret, nil
}